This is to go along with the newly introduced GdkDrop.
This commit includes the necessary updates to the X11, Wayland
and Broadway backends. Other backends have to be updated separately.
static void
drag_begin (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
gpointer data)
{
GdkPaintable *paintable;
paintable = get_image_paintable (GTK_IMAGE (widget));
if (paintable)
{
- gtk_drag_set_icon_paintable (context, paintable, -2, -2);
+ gtk_drag_set_icon_paintable (drag, paintable, -2, -2);
g_object_unref (paintable);
}
}
void
drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data,
guint info,
gpointer data)
static void
get_image_data (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection,
guint target_info,
gpointer data)
static void
get_scalable_image_data (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection,
guint target_info,
gpointer data)
#include <string.h>
-#define GDK_TYPE_BROADWAY_DRAG_CONTEXT (gdk_broadway_drag_context_get_type ())
-#define GDK_BROADWAY_DRAG_CONTEXT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_BROADWAY_DRAG_CONTEXT, GdkBroadwayDragContext))
-#define GDK_BROADWAY_DRAG_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_BROADWAY_DRAG_CONTEXT, GdkBroadwayDragContextClass))
-#define GDK_IS_BROADWAY_DRAG_CONTEXT(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_BROADWAY_DRAG_CONTEXT))
-#define GDK_IS_BROADWAY_DRAG_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_BROADWAY_DRAG_CONTEXT))
-#define GDK_BROADWAY_DRAG_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_BROADWAY_DRAG_CONTEXT, GdkBroadwayDragContextClass))
+#define GDK_TYPE_BROADWAY_DRAG (gdk_broadway_drag_get_type ())
+#define GDK_BROADWAY_DRAG(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_BROADWAY_DRAG, GdkBroadwayDrag))
+#define GDK_BROADWAY_DRAG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_BROADWAY_DRAG, GdkBroadwayDragClass))
+#define GDK_IS_BROADWAY_DRAG(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_BROADWAY_DRAG))
+#define GDK_IS_BROADWAY_DRAG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_BROADWAY_DRAG))
+#define GDK_BROADWAY_DRAG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_BROADWAY_DRAG, GdkBroadwayDragClass))
#ifdef GDK_COMPILATION
-typedef struct _GdkBroadwayDragContext GdkBroadwayDragContext;
+typedef struct _GdkBroadwayDrag GdkBroadwayDrag;
#else
-typedef GdkDragContext GdkBroadwayDragContext;
+typedef GdkDrag GdkBroadwayDrag;
#endif
-typedef struct _GdkBroadwayDragContextClass GdkBroadwayDragContextClass;
+typedef struct _GdkBroadwayDragClass GdkBroadwayDragClass;
-GType gdk_broadway_drag_context_get_type (void);
+GType gdk_broadway_drag_get_type (void);
-struct _GdkBroadwayDragContext {
- GdkDragContext context;
+struct _GdkBroadwayDrag {
+ GdkDrag context;
};
-struct _GdkBroadwayDragContextClass
+struct _GdkBroadwayDragClass
{
- GdkDragContextClass parent_class;
+ GdkDragClass parent_class;
};
-static void gdk_broadway_drag_context_finalize (GObject *object);
+static void gdk_broadway_drag_finalize (GObject *object);
static GList *contexts;
-G_DEFINE_TYPE (GdkBroadwayDragContext, gdk_broadway_drag_context, GDK_TYPE_DRAG_CONTEXT)
+G_DEFINE_TYPE (GdkBroadwayDrag, gdk_broadway_drag, GDK_TYPE_DRAG)
static void
-gdk_broadway_drag_context_init (GdkBroadwayDragContext *dragcontext)
+gdk_broadway_drag_init (GdkBroadwayDrag *dragcontext)
{
contexts = g_list_prepend (contexts, dragcontext);
}
static void
-gdk_broadway_drag_context_finalize (GObject *object)
+gdk_broadway_drag_finalize (GObject *object)
{
- GdkDragContext *context = GDK_DRAG_CONTEXT (object);
+ GdkDrag *context = GDK_DRAG (object);
contexts = g_list_remove (contexts, context);
- G_OBJECT_CLASS (gdk_broadway_drag_context_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gdk_broadway_drag_parent_class)->finalize (object);
}
/* Drag Contexts */
-GdkDragContext *
+GdkDrag *
_gdk_broadway_surface_drag_begin (GdkSurface *surface,
GdkDevice *device,
GdkContentProvider *content,
gint dx,
gint dy)
{
- GdkDragContext *new_context;
+ GdkDrag *new_context;
g_return_val_if_fail (surface != NULL, NULL);
g_return_val_if_fail (GDK_SURFACE_IS_BROADWAY (surface), NULL);
- new_context = g_object_new (GDK_TYPE_BROADWAY_DRAG_CONTEXT,
+ new_context = g_object_new (GDK_TYPE_BROADWAY_DRAG,
"device", device,
"content", content,
NULL);
}
static void
-gdk_broadway_drag_context_drag_drop (GdkDragContext *context,
+gdk_broadway_drag_drag_drop (GdkDrag *context,
guint32 time)
{
g_return_if_fail (context != NULL);
}
static void
-gdk_broadway_drag_context_drag_abort (GdkDragContext *context,
+gdk_broadway_drag_drag_abort (GdkDrag *context,
guint32 time)
{
g_return_if_fail (context != NULL);
}
static void
-gdk_broadway_drag_context_class_init (GdkBroadwayDragContextClass *klass)
+gdk_broadway_drag_class_init (GdkBroadwayDragClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
- GdkDragContextClass *context_class = GDK_DRAG_CONTEXT_CLASS (klass);
+ GdkDragClass *context_class = GDK_DRAG_CLASS (klass);
- object_class->finalize = gdk_broadway_drag_context_finalize;
+ object_class->finalize = gdk_broadway_drag_finalize;
- context_class->drag_abort = gdk_broadway_drag_context_drag_abort;
- context_class->drag_drop = gdk_broadway_drag_context_drag_drop;
+ context_class->drag_abort = gdk_broadway_drag_drag_abort;
+ context_class->drag_drop = gdk_broadway_drag_drag_drop;
}
GPtrArray *node_textures);
void _gdk_broadway_surface_register_dnd (GdkSurface *surface);
-GdkDragContext * _gdk_broadway_surface_drag_begin (GdkSurface *surface,
+GdkDrag * _gdk_broadway_surface_drag_begin (GdkSurface *surface,
GdkDevice *device,
GdkContentProvider *content,
GdkDragAction actions,
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkDevice, g_object_unref)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkDisplay, g_object_unref)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkDisplayManager, g_object_unref)
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkDragContext, g_object_unref)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkDrag, g_object_unref)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkDrawContext, g_object_unref)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkFrameClock, g_object_unref)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkGLContext, g_object_unref)
#include "gdkenumtypes.h"
#include "gdkeventsprivate.h"
-typedef struct _GdkDragContextPrivate GdkDragContextPrivate;
+typedef struct _GdkDragPrivate GdkDragPrivate;
-struct _GdkDragContextPrivate
+struct _GdkDragPrivate
{
GdkDisplay *display;
GdkDevice *device;
static GParamSpec *properties[N_PROPERTIES] = { NULL, };
static guint signals[N_SIGNALS] = { 0 };
-static GList *contexts = NULL;
+static GList *drags = NULL;
-G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GdkDragContext, gdk_drag_context, G_TYPE_OBJECT)
+G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (GdkDrag, gdk_drag, G_TYPE_OBJECT)
/**
* SECTION:dnd
*/
/**
- * GdkDragContext:
+ * GdkDrag:
*
- * The GdkDragContext struct contains only private fields and
+ * The GdkDrag struct contains only private fields and
* should not be accessed directly.
*/
/**
- * gdk_drag_context_get_display:
- * @context: a #GdkDragContext
+ * gdk_drag_get_display:
+ * @drag: a #GdkDrag
*
- * Gets the #GdkDisplay that the drag context was created for.
+ * Gets the #GdkDisplay that the drag object was created for.
*
* Returns: (transfer none): a #GdkDisplay
**/
GdkDisplay *
-gdk_drag_context_get_display (GdkDragContext *context)
+gdk_drag_get_display (GdkDrag *drag)
{
- GdkDragContextPrivate *priv = gdk_drag_context_get_instance_private (context);
+ GdkDragPrivate *priv = gdk_drag_get_instance_private (drag);
- g_return_val_if_fail (GDK_IS_DRAG_CONTEXT (context), NULL);
+ g_return_val_if_fail (GDK_IS_DRAG (drag), NULL);
return priv->display;
}
/**
- * gdk_drag_context_get_formats:
- * @context: a #GdkDragContext
+ * gdk_drag_get_formats:
+ * @drag: a #GdkDrag
*
- * Retrieves the formats supported by this context.
+ * Retrieves the formats supported by this GdkDrag object.
*
* Returns: (transfer none): a #GdkContentFormats
**/
GdkContentFormats *
-gdk_drag_context_get_formats (GdkDragContext *context)
+gdk_drag_get_formats (GdkDrag *drag)
{
- GdkDragContextPrivate *priv = gdk_drag_context_get_instance_private (context);
+ GdkDragPrivate *priv = gdk_drag_get_instance_private (drag);
- g_return_val_if_fail (GDK_IS_DRAG_CONTEXT (context), NULL);
+ g_return_val_if_fail (GDK_IS_DRAG (drag), NULL);
return priv->formats;
}
/**
- * gdk_drag_context_get_actions:
- * @context: a #GdkDragContext
+ * gdk_drag_get_actions:
+ * @drag: a #GdkDrag
*
* Determines the bitmask of actions proposed by the source if
- * gdk_drag_context_get_suggested_action() returns %GDK_ACTION_ASK.
+ * gdk_drag_get_suggested_action() returns %GDK_ACTION_ASK.
*
* Returns: the #GdkDragAction flags
**/
GdkDragAction
-gdk_drag_context_get_actions (GdkDragContext *context)
+gdk_drag_get_actions (GdkDrag *drag)
{
- GdkDragContextPrivate *priv = gdk_drag_context_get_instance_private (context);
+ GdkDragPrivate *priv = gdk_drag_get_instance_private (drag);
- g_return_val_if_fail (GDK_IS_DRAG_CONTEXT (context), 0);
+ g_return_val_if_fail (GDK_IS_DRAG (drag), 0);
return priv->actions;
}
/**
- * gdk_drag_context_get_suggested_action:
- * @context: a #GdkDragContext
+ * gdk_drag_get_suggested_action:
+ * @drag: a #GdkDrag
*
- * Determines the suggested drag action of the context.
+ * Determines the suggested drag action of the GdkDrag object.
*
* Returns: a #GdkDragAction value
**/
GdkDragAction
-gdk_drag_context_get_suggested_action (GdkDragContext *context)
+gdk_drag_get_suggested_action (GdkDrag *drag)
{
- GdkDragContextPrivate *priv = gdk_drag_context_get_instance_private (context);
+ GdkDragPrivate *priv = gdk_drag_get_instance_private (drag);
- g_return_val_if_fail (GDK_IS_DRAG_CONTEXT (context), 0);
+ g_return_val_if_fail (GDK_IS_DRAG (drag), 0);
return priv->suggested_action;
}
/**
- * gdk_drag_context_get_selected_action:
- * @context: a #GdkDragContext
+ * gdk_drag_get_selected_action:
+ * @drag: a #GdkDrag
*
* Determines the action chosen by the drag destination.
*
* Returns: a #GdkDragAction value
**/
GdkDragAction
-gdk_drag_context_get_selected_action (GdkDragContext *context)
+gdk_drag_get_selected_action (GdkDrag *drag)
{
- g_return_val_if_fail (GDK_IS_DRAG_CONTEXT (context), 0);
+ g_return_val_if_fail (GDK_IS_DRAG (drag), 0);
- return context->action;
+ return drag->action;
}
/**
- * gdk_drag_context_get_device:
- * @context: a #GdkDragContext
+ * gdk_drag_get_device:
+ * @drag: a #GdkDrag
*
- * Returns the #GdkDevice associated to the drag context.
+ * Returns the #GdkDevice associated to the GdkDrag object.
*
- * Returns: (transfer none): The #GdkDevice associated to @context.
+ * Returns: (transfer none): The #GdkDevice associated to @drag.
**/
GdkDevice *
-gdk_drag_context_get_device (GdkDragContext *context)
+gdk_drag_get_device (GdkDrag *drag)
{
- GdkDragContextPrivate *priv = gdk_drag_context_get_instance_private (context);
+ GdkDragPrivate *priv = gdk_drag_get_instance_private (drag);
- g_return_val_if_fail (GDK_IS_DRAG_CONTEXT (context), NULL);
+ g_return_val_if_fail (GDK_IS_DRAG (drag), NULL);
return priv->device;
}
static void
-gdk_drag_context_init (GdkDragContext *context)
+gdk_drag_init (GdkDrag *drag)
{
- contexts = g_list_prepend (contexts, context);
+ drags = g_list_prepend (drags, drag);
}
static void
-gdk_drag_context_set_property (GObject *gobject,
- guint prop_id,
- const GValue *value,
- GParamSpec *pspec)
+gdk_drag_set_property (GObject *gobject,
+ guint prop_id,
+ const GValue *value,
+ GParamSpec *pspec)
{
- GdkDragContext *context = GDK_DRAG_CONTEXT (gobject);
- GdkDragContextPrivate *priv = gdk_drag_context_get_instance_private (context);
+ GdkDrag *drag = GDK_DRAG (gobject);
+ GdkDragPrivate *priv = gdk_drag_get_instance_private (drag);
switch (prop_id)
{
case PROP_CONTENT:
- context->content = g_value_dup_object (value);
- if (context->content)
+ drag->content = g_value_dup_object (value);
+ if (drag->content)
{
g_assert (priv->formats == NULL);
- priv->formats = gdk_content_provider_ref_formats (context->content);
+ priv->formats = gdk_content_provider_ref_formats (drag->content);
}
break;
}
static void
-gdk_drag_context_get_property (GObject *gobject,
- guint prop_id,
- GValue *value,
- GParamSpec *pspec)
+gdk_drag_get_property (GObject *gobject,
+ guint prop_id,
+ GValue *value,
+ GParamSpec *pspec)
{
- GdkDragContext *context = GDK_DRAG_CONTEXT (gobject);
- GdkDragContextPrivate *priv = gdk_drag_context_get_instance_private (context);
+ GdkDrag *drag = GDK_DRAG (gobject);
+ GdkDragPrivate *priv = gdk_drag_get_instance_private (drag);
switch (prop_id)
{
case PROP_CONTENT:
- g_value_set_object (value, context->content);
+ g_value_set_object (value, drag->content);
break;
case PROP_DEVICE:
}
static void
-gdk_drag_context_finalize (GObject *object)
+gdk_drag_finalize (GObject *object)
{
- GdkDragContext *context = GDK_DRAG_CONTEXT (object);
- GdkDragContextPrivate *priv = gdk_drag_context_get_instance_private (context);
+ GdkDrag *drag = GDK_DRAG (object);
+ GdkDragPrivate *priv = gdk_drag_get_instance_private (drag);
- contexts = g_list_remove (contexts, context);
+ drags = g_list_remove (drags, drag);
- g_clear_object (&context->content);
+ g_clear_object (&drag->content);
g_clear_pointer (&priv->formats, gdk_content_formats_unref);
- if (context->source_surface)
- g_object_unref (context->source_surface);
+ if (drag->source_surface)
+ g_object_unref (drag->source_surface);
- G_OBJECT_CLASS (gdk_drag_context_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gdk_drag_parent_class)->finalize (object);
}
static void
-gdk_drag_context_class_init (GdkDragContextClass *klass)
+gdk_drag_class_init (GdkDragClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
- object_class->get_property = gdk_drag_context_get_property;
- object_class->set_property = gdk_drag_context_set_property;
- object_class->finalize = gdk_drag_context_finalize;
+ object_class->get_property = gdk_drag_get_property;
+ object_class->set_property = gdk_drag_set_property;
+ object_class->finalize = gdk_drag_finalize;
/**
- * GdkDragContext:content:
+ * GdkDrag:content:
*
- * The #GdkContentProvider or %NULL if the context is not a source-side
- * context.
+ * The #GdkContentProvider.
*/
properties[PROP_CONTENT] =
g_param_spec_object ("content",
G_PARAM_EXPLICIT_NOTIFY);
/**
- * GdkDragContext:device:
+ * GdkDrag:device:
*
* The #GdkDevice that is performing the drag.
*/
G_PARAM_EXPLICIT_NOTIFY);
/**
- * GdkDragContext:display:
+ * GdkDrag:display:
*
- * The #GdkDisplay that the drag context belongs to.
+ * The #GdkDisplay that the drag belongs to.
*/
properties[PROP_DISPLAY] =
g_param_spec_object ("display",
G_PARAM_EXPLICIT_NOTIFY);
/**
- * GdkDragContext:formats:
+ * GdkDrag:formats:
*
- * The possible formats that the context can provide its data in.
+ * The possible formats that the drag can provide its data in.
*/
properties[PROP_FORMATS] =
g_param_spec_boxed ("formats",
G_PARAM_EXPLICIT_NOTIFY);
/**
- * GdkDragContext::cancel:
- * @context: The object on which the signal is emitted
- * @reason: The reason the context was cancelled
+ * GdkDrag::cancel:
+ * @drag: The object on which the signal is emitted
+ * @reason: The reason the drag was cancelled
*
- * The drag and drop operation was cancelled.
+ * The drag operation was cancelled.
*/
signals[CANCEL] =
g_signal_new (g_intern_static_string ("cancel"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GdkDragContextClass, cancel),
+ G_STRUCT_OFFSET (GdkDragClass, cancel),
NULL, NULL,
g_cclosure_marshal_VOID__ENUM,
G_TYPE_NONE, 1, GDK_TYPE_DRAG_CANCEL_REASON);
/**
- * GdkDragContext::drop-performed:
- * @context: The object on which the signal is emitted
+ * GdkDrag::drop-performed:
+ * @drag: The object on which the signal is emitted
*
- * The drag and drop operation was performed on an accepting client.
+ * The drag operation was performed on an accepting client.
*/
signals[DROP_PERFORMED] =
g_signal_new (g_intern_static_string ("drop-performed"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GdkDragContextClass, drop_performed),
+ G_STRUCT_OFFSET (GdkDragClass, drop_performed),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
/**
- * GdkDragContext::dnd-finished:
- * @context: The object on which the signal is emitted
+ * GdkDrag::dnd-finished:
+ * @drag: The object on which the signal is emitted
*
- * The drag and drop operation was finished, the drag destination
- * finished reading all data. The drag source can now free all
- * miscellaneous data.
+ * The drag operation was finished, the destination
+ * finished reading all data. The drag object can now
+ * free all miscellaneous data.
*/
signals[DND_FINISHED] =
g_signal_new (g_intern_static_string ("dnd-finished"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GdkDragContextClass, dnd_finished),
+ G_STRUCT_OFFSET (GdkDragClass, dnd_finished),
NULL, NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
/**
- * GdkDragContext::action-changed:
- * @context: The object on which the signal is emitted
+ * GdkDrag::action-changed:
+ * @drag: The object on which the signal is emitted
* @action: The action currently chosen
*
- * A new action is being chosen for the drag and drop operation.
+ * A new action is being chosen for the drag operation.
*/
signals[ACTION_CHANGED] =
g_signal_new (g_intern_static_string ("action-changed"),
G_TYPE_FROM_CLASS (object_class),
G_SIGNAL_RUN_LAST,
- G_STRUCT_OFFSET (GdkDragContextClass, action_changed),
+ G_STRUCT_OFFSET (GdkDragClass, action_changed),
NULL, NULL,
g_cclosure_marshal_VOID__FLAGS,
G_TYPE_NONE, 1, GDK_TYPE_DRAG_ACTION);
/*
* gdk_drag_abort:
- * @context: a #GdkDragContext
+ * @drag: a #GdkDrag
* @time_: the timestamp for this operation
*
* Aborts a drag without dropping.
* This function is called by the drag source.
*/
void
-gdk_drag_abort (GdkDragContext *context,
- guint32 time_)
+gdk_drag_abort (GdkDrag *drag,
+ guint32 time_)
{
- g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
+ g_return_if_fail (GDK_IS_DRAG (drag));
- GDK_DRAG_CONTEXT_GET_CLASS (context)->drag_abort (context, time_);
+ GDK_DRAG_GET_CLASS (drag)->drag_abort (drag, time_);
}
/*
* gdk_drag_drop:
- * @context: a #GdkDragContext
+ * @drag: a #GdkDrag
* @time_: the timestamp for this operation
*
* Drops on the current destination.
* This function is called by the drag source.
*/
void
-gdk_drag_drop (GdkDragContext *context,
- guint32 time_)
+gdk_drag_drop (GdkDrag *drag,
+ guint32 time_)
{
- g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
+ g_return_if_fail (GDK_IS_DRAG (drag));
- GDK_DRAG_CONTEXT_GET_CLASS (context)->drag_drop (context, time_);
+ GDK_DRAG_GET_CLASS (drag)->drag_drop (drag, time_);
}
static void
-gdk_drag_context_write_done (GObject *content,
- GAsyncResult *result,
- gpointer task)
+gdk_drag_write_done (GObject *content,
+ GAsyncResult *result,
+ gpointer task)
{
GError *error = NULL;
}
static void
-gdk_drag_context_write_serialize_done (GObject *content,
- GAsyncResult *result,
- gpointer task)
+gdk_drag_write_serialize_done (GObject *content,
+ GAsyncResult *result,
+ gpointer task)
{
GError *error = NULL;
}
void
-gdk_drag_context_write_async (GdkDragContext *context,
- const char *mime_type,
- GOutputStream *stream,
- int io_priority,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data)
+gdk_drag_write_async (GdkDrag *drag,
+ const char *mime_type,
+ GOutputStream *stream,
+ int io_priority,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data)
{
GdkContentFormats *formats, *mime_formats;
GTask *task;
GType gtype;
- g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
- g_return_if_fail (context->content);
+ g_return_if_fail (GDK_IS_DRAG (drag));
+ g_return_if_fail (drag->content);
g_return_if_fail (mime_type != NULL);
g_return_if_fail (mime_type == g_intern_string (mime_type));
g_return_if_fail (G_IS_OUTPUT_STREAM (stream));
g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable));
g_return_if_fail (callback != NULL);
- task = g_task_new (context, cancellable, callback, user_data);
+ task = g_task_new (drag, cancellable, callback, user_data);
g_task_set_priority (task, io_priority);
- g_task_set_source_tag (task, gdk_drag_context_write_async);
+ g_task_set_source_tag (task, gdk_drag_write_async);
- formats = gdk_content_provider_ref_formats (context->content);
+ formats = gdk_content_provider_ref_formats (drag->content);
if (gdk_content_formats_contain_mime_type (formats, mime_type))
{
- gdk_content_provider_write_mime_type_async (context->content,
+ gdk_content_provider_write_mime_type_async (drag->content,
mime_type,
stream,
io_priority,
cancellable,
- gdk_drag_context_write_done,
+ gdk_drag_write_done,
task);
gdk_content_formats_unref (formats);
return;
g_assert (gtype != G_TYPE_INVALID);
g_value_init (&value, gtype);
- if (gdk_content_provider_get_value (context->content, &value, &error))
+ if (gdk_content_provider_get_value (drag->content, &value, &error))
{
gdk_content_serialize_async (stream,
mime_type,
&value,
io_priority,
cancellable,
- gdk_drag_context_write_serialize_done,
+ gdk_drag_write_serialize_done,
g_object_ref (task));
}
else
}
gboolean
-gdk_drag_context_write_finish (GdkDragContext *context,
- GAsyncResult *result,
- GError **error)
+gdk_drag_write_finish (GdkDrag *drag,
+ GAsyncResult *result,
+ GError **error)
{
- g_return_val_if_fail (g_task_is_valid (result, context), FALSE);
- g_return_val_if_fail (g_task_get_source_tag (G_TASK (result)) == gdk_drag_context_write_async, FALSE);
+ g_return_val_if_fail (g_task_is_valid (result, drag), FALSE);
+ g_return_val_if_fail (g_task_get_source_tag (G_TASK (result)) == gdk_drag_write_async, FALSE);
return g_task_propagate_boolean (G_TASK (result), error);
}
void
-gdk_drag_context_set_actions (GdkDragContext *context,
- GdkDragAction actions,
- GdkDragAction suggested_action)
+gdk_drag_set_actions (GdkDrag *drag,
+ GdkDragAction actions,
+ GdkDragAction suggested_action)
{
- GdkDragContextPrivate *priv = gdk_drag_context_get_instance_private (context);
+ GdkDragPrivate *priv = gdk_drag_get_instance_private (drag);
priv->actions = actions;
priv->suggested_action = suggested_action;
}
/**
- * gdk_drag_context_get_drag_surface:
- * @context: a #GdkDragContext
+ * gdk_drag_get_drag_surface:
+ * @drag: a #GdkDrag
*
* Returns the surface on which the drag icon should be rendered
* during the drag operation. Note that the surface may not be
* available until the drag operation has begun. GDK will move
* the surface in accordance with the ongoing drag operation.
- * The surface is owned by @context and will be destroyed when
+ * The surface is owned by @drag and will be destroyed when
* the drag operation is over.
*
* Returns: (nullable) (transfer none): the drag surface, or %NULL
*/
GdkSurface *
-gdk_drag_context_get_drag_surface (GdkDragContext *context)
+gdk_drag_get_drag_surface (GdkDrag *drag)
{
- g_return_val_if_fail (GDK_IS_DRAG_CONTEXT (context), NULL);
+ g_return_val_if_fail (GDK_IS_DRAG (drag), NULL);
- if (GDK_DRAG_CONTEXT_GET_CLASS (context)->get_drag_surface)
- return GDK_DRAG_CONTEXT_GET_CLASS (context)->get_drag_surface (context);
+ if (GDK_DRAG_GET_CLASS (drag)->get_drag_surface)
+ return GDK_DRAG_GET_CLASS (drag)->get_drag_surface (drag);
return NULL;
}
/**
- * gdk_drag_context_set_hotspot:
- * @context: a #GdkDragContext
+ * gdk_drag_set_hotspot:
+ * @drag: a #GdkDrag
* @hot_x: x coordinate of the drag surface hotspot
* @hot_y: y coordinate of the drag surface hotspot
*
* top left corner of the drag surface.
*/
void
-gdk_drag_context_set_hotspot (GdkDragContext *context,
- gint hot_x,
- gint hot_y)
+gdk_drag_set_hotspot (GdkDrag *drag,
+ gint hot_x,
+ gint hot_y)
{
- g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
+ g_return_if_fail (GDK_IS_DRAG (drag));
- if (GDK_DRAG_CONTEXT_GET_CLASS (context)->set_hotspot)
- GDK_DRAG_CONTEXT_GET_CLASS (context)->set_hotspot (context, hot_x, hot_y);
+ if (GDK_DRAG_GET_CLASS (drag)->set_hotspot)
+ GDK_DRAG_GET_CLASS (drag)->set_hotspot (drag, hot_x, hot_y);
}
/**
* gdk_drag_drop_done:
- * @context: a #GdkDragContext
+ * @drag: a #GdkDrag
* @success: whether the drag was ultimatively successful
*
* Inform GDK if the drop ended successfully. Passing %FALSE
*
* This function is called by the drag source, and should
* be the last call before dropping the reference to the
- * @context.
+ * @drag.
*
- * The #GdkDragContext will only take the first gdk_drag_drop_done()
+ * The #GdkDrag will only take the first gdk_drag_drop_done()
* call as effective, if this function is called multiple times,
* all subsequent calls will be ignored.
*/
void
-gdk_drag_drop_done (GdkDragContext *context,
- gboolean success)
+gdk_drag_drop_done (GdkDrag *drag,
+ gboolean success)
{
- g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
+ g_return_if_fail (GDK_IS_DRAG (drag));
- if (context->drop_done)
+ if (drag->drop_done)
return;
- context->drop_done = TRUE;
+ drag->drop_done = TRUE;
- if (GDK_DRAG_CONTEXT_GET_CLASS (context)->drop_done)
- GDK_DRAG_CONTEXT_GET_CLASS (context)->drop_done (context, success);
+ if (GDK_DRAG_GET_CLASS (drag)->drop_done)
+ GDK_DRAG_GET_CLASS (drag)->drop_done (drag, success);
}
void
-gdk_drag_context_set_cursor (GdkDragContext *context,
- GdkCursor *cursor)
+gdk_drag_set_cursor (GdkDrag *drag,
+ GdkCursor *cursor)
{
- g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
+ g_return_if_fail (GDK_IS_DRAG (drag));
- if (GDK_DRAG_CONTEXT_GET_CLASS (context)->set_cursor)
- GDK_DRAG_CONTEXT_GET_CLASS (context)->set_cursor (context, cursor);
+ if (GDK_DRAG_GET_CLASS (drag)->set_cursor)
+ GDK_DRAG_GET_CLASS (drag)->set_cursor (drag, cursor);
}
void
-gdk_drag_context_cancel (GdkDragContext *context,
- GdkDragCancelReason reason)
+gdk_drag_cancel (GdkDrag *drag,
+ GdkDragCancelReason reason)
{
- g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
+ g_return_if_fail (GDK_IS_DRAG (drag));
- g_signal_emit (context, signals[CANCEL], 0, reason);
+ g_signal_emit (drag, signals[CANCEL], 0, reason);
}
gboolean
-gdk_drag_context_handle_source_event (GdkEvent *event)
+gdk_drag_handle_source_event (GdkEvent *event)
{
- GdkDragContext *context;
+ GdkDrag *drag;
GList *l;
- for (l = contexts; l; l = l->next)
+ for (l = drags; l; l = l->next)
{
- context = l->data;
+ drag = l->data;
- if (!GDK_DRAG_CONTEXT_GET_CLASS (context)->handle_event)
+ if (!GDK_DRAG_GET_CLASS (drag)->handle_event)
continue;
- if (GDK_DRAG_CONTEXT_GET_CLASS (context)->handle_event (context, event))
+ if (GDK_DRAG_GET_CLASS (drag)->handle_event (drag, event))
return TRUE;
}
}
GdkCursor *
-gdk_drag_get_cursor (GdkDragContext *context,
- GdkDragAction action)
+gdk_drag_get_cursor (GdkDrag *drag,
+ GdkDragAction action)
{
gint i;
G_BEGIN_DECLS
-#define GDK_TYPE_DRAG_CONTEXT (gdk_drag_context_get_type ())
-#define GDK_DRAG_CONTEXT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DRAG_CONTEXT, GdkDragContext))
-#define GDK_IS_DRAG_CONTEXT(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DRAG_CONTEXT))
+#define GDK_TYPE_DRAG (gdk_drag_get_type ())
+#define GDK_DRAG(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DRAG, GdkDrag))
+#define GDK_IS_DRAG(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_DRAG))
/**
* GdkDragCancelReason:
* @GDK_DRAG_CANCEL_USER_CANCELLED: Drag cancelled by the user
* @GDK_DRAG_CANCEL_ERROR: Unspecified error.
*
- * Used in #GdkDragContext to the reason of a cancelled DND operation.
+ * Used in #GdkDrag to the reason of a cancelled DND operation.
*/
typedef enum {
GDK_DRAG_CANCEL_NO_TARGET,
} GdkDragCancelReason;
GDK_AVAILABLE_IN_ALL
-GType gdk_drag_context_get_type (void) G_GNUC_CONST;
+GType gdk_drag_get_type (void) G_GNUC_CONST;
GDK_AVAILABLE_IN_ALL
-GdkDisplay * gdk_drag_context_get_display (GdkDragContext *context);
+GdkDisplay * gdk_drag_get_display (GdkDrag *drag);
GDK_AVAILABLE_IN_ALL
-GdkDevice * gdk_drag_context_get_device (GdkDragContext *context);
+GdkDevice * gdk_drag_get_device (GdkDrag *drag);
GDK_AVAILABLE_IN_ALL
-GdkContentFormats *gdk_drag_context_get_formats (GdkDragContext *context);
+GdkContentFormats *gdk_drag_get_formats (GdkDrag *drag);
GDK_AVAILABLE_IN_ALL
-GdkDragAction gdk_drag_context_get_actions (GdkDragContext *context);
+GdkDragAction gdk_drag_get_actions (GdkDrag *drag);
GDK_AVAILABLE_IN_ALL
-GdkDragAction gdk_drag_context_get_suggested_action (GdkDragContext *context);
+GdkDragAction gdk_drag_get_suggested_action (GdkDrag *drag);
GDK_AVAILABLE_IN_ALL
-GdkDragAction gdk_drag_context_get_selected_action (GdkDragContext *context);
+GdkDragAction gdk_drag_get_selected_action (GdkDrag *drag);
GDK_AVAILABLE_IN_ALL
-gboolean gdk_drag_action_is_unique (GdkDragAction action);
-
-/* Source side */
+gboolean gdk_drag_action_is_unique (GdkDragAction action);
GDK_AVAILABLE_IN_ALL
-GdkDragContext * gdk_drag_begin (GdkSurface *surface,
- GdkDevice *device,
- GdkContentProvider *content,
- GdkDragAction actions,
- gint dx,
- gint dy);
+GdkDrag * gdk_drag_begin (GdkSurface *surface,
+ GdkDevice *device,
+ GdkContentProvider *content,
+ GdkDragAction actions,
+ gint dx,
+ gint dy);
GDK_AVAILABLE_IN_ALL
-void gdk_drag_drop_done (GdkDragContext *context,
- gboolean success);
+void gdk_drag_drop_done (GdkDrag *drag,
+ gboolean success);
GDK_AVAILABLE_IN_ALL
-GdkSurface *gdk_drag_context_get_drag_surface (GdkDragContext *context);
+GdkSurface *gdk_drag_get_drag_surface (GdkDrag *drag);
GDK_AVAILABLE_IN_ALL
-void gdk_drag_context_set_hotspot (GdkDragContext *context,
- gint hot_x,
- gint hot_y);
+void gdk_drag_set_hotspot (GdkDrag *drag,
+ gint hot_x,
+ gint hot_y);
G_END_DECLS
G_BEGIN_DECLS
-#define GDK_DRAG_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_DRAG_CONTEXT, GdkDragContextClass))
-#define GDK_IS_DRAG_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_DRAG_CONTEXT))
-#define GDK_DRAG_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_DRAG_CONTEXT, GdkDragContextClass))
+#define GDK_DRAG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_DRAG, GdkDragClass))
+#define GDK_IS_DRAG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_DRAG))
+#define GDK_DRAG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_DRAG, GdkDragClass))
-typedef struct _GdkDragContextClass GdkDragContextClass;
+typedef struct _GdkDragClass GdkDragClass;
-struct _GdkDragContextClass {
+struct _GdkDragClass {
GObjectClass parent_class;
- void (*drag_abort) (GdkDragContext *context,
+ void (*drag_abort) (GdkDrag *drag,
guint32 time_);
- void (*drag_drop) (GdkDragContext *context,
+ void (*drag_drop) (GdkDrag *drag,
guint32 time_);
- GdkSurface* (*get_drag_surface) (GdkDragContext *context);
- void (*set_hotspot) (GdkDragContext *context,
+ GdkSurface* (*get_drag_surface) (GdkDrag *drag);
+ void (*set_hotspot) (GdkDrag *drag,
gint hot_x,
gint hot_y);
- void (*drop_done) (GdkDragContext *context,
+ void (*drop_done) (GdkDrag *drag,
gboolean success);
- void (*set_cursor) (GdkDragContext *context,
+ void (*set_cursor) (GdkDrag *drag,
GdkCursor *cursor);
- void (*cancel) (GdkDragContext *context,
+ void (*cancel) (GdkDrag *drag,
GdkDragCancelReason reason);
- void (*drop_performed) (GdkDragContext *context,
+ void (*drop_performed) (GdkDrag *drag,
guint32 time);
- void (*dnd_finished) (GdkDragContext *context);
+ void (*dnd_finished) (GdkDrag *drag);
- gboolean (*handle_event) (GdkDragContext *context,
+ gboolean (*handle_event) (GdkDrag *drag,
const GdkEvent *event);
- void (*action_changed) (GdkDragContext *context,
+ void (*action_changed) (GdkDrag *drag,
GdkDragAction action);
};
-struct _GdkDragContext {
+struct _GdkDrag {
GObject parent_instance;
/*< private >*/
guint drop_done : 1; /* Whether gdk_drag_drop_done() was performed */
};
-void gdk_drag_context_set_cursor (GdkDragContext *context,
- GdkCursor *cursor);
-void gdk_drag_context_set_actions (GdkDragContext *context,
- GdkDragAction actions,
- GdkDragAction suggested_action);
-
-void gdk_drag_context_cancel (GdkDragContext *context,
- GdkDragCancelReason reason);
-gboolean gdk_drag_context_handle_source_event (GdkEvent *event);
-GdkCursor * gdk_drag_get_cursor (GdkDragContext *context,
- GdkDragAction action);
-
-void gdk_drag_abort (GdkDragContext *context,
- guint32 time_);
-void gdk_drag_drop (GdkDragContext *context,
- guint32 time_);
-
-void gdk_drag_context_write_async (GdkDragContext *context,
- const char *mime_type,
- GOutputStream *stream,
- int io_priority,
- GCancellable *cancellable,
- GAsyncReadyCallback callback,
- gpointer user_data);
-gboolean gdk_drag_context_write_finish (GdkDragContext *context,
- GAsyncResult *result,
- GError **error);
+void gdk_drag_set_cursor (GdkDrag *drag,
+ GdkCursor *cursor);
+void gdk_drag_set_actions (GdkDrag *drag,
+ GdkDragAction actions,
+ GdkDragAction suggested_action);
+
+void gdk_drag_cancel (GdkDrag *drag,
+ GdkDragCancelReason reason);
+gboolean gdk_drag_handle_source_event (GdkEvent *event);
+GdkCursor * gdk_drag_get_cursor (GdkDrag *drag,
+ GdkDragAction action);
+
+void gdk_drag_abort (GdkDrag *drag,
+ guint32 time_);
+void gdk_drag_drop (GdkDrag *drag,
+ guint32 time_);
+
+void gdk_drag_write_async (GdkDrag *drag,
+ const char *mime_type,
+ GOutputStream *stream,
+ int io_priority,
+ GCancellable *cancellable,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
+gboolean gdk_drag_write_finish (GdkDrag *drag,
+ GAsyncResult *result,
+ GError **error);
G_END_DECLS
struct _GdkDropPrivate {
GdkDevice *device;
- GdkDragContext *drag;
+ GdkDrag *drag;
GdkContentFormats *formats;
GdkSurface *surface;
GdkDragAction actions;
gpointer stream)
{
/* we don't care about the error, we just want to clean up */
- gdk_drag_context_write_finish (GDK_DRAG_CONTEXT (drag), result, NULL);
+ gdk_drag_write_finish (GDK_DRAG (drag), result, NULL);
/* XXX: Do we need to close_async() here? */
g_output_stream_close (stream, NULL, NULL);
stream = gdk_pipe_io_stream_new ();
output_stream = g_io_stream_get_output_stream (stream);
- gdk_drag_context_write_async (priv->drag,
+ gdk_drag_write_async (priv->drag,
mime_type,
output_stream,
io_priority,
g_param_spec_object ("drag",
"Drag",
"The drag that initiated this drop",
- GDK_TYPE_DRAG_CONTEXT,
+ GDK_TYPE_DRAG,
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_STATIC_STRINGS |
*
* Returns: (transfer none) (nullable): the corresponding #GdkDrag
**/
-GdkDragContext *
+GdkDrag *
gdk_drop_get_drag (GdkDrop *self)
{
GdkDropPrivate *priv = gdk_drop_get_instance_private (self);
GDK_AVAILABLE_IN_ALL
GdkDragAction gdk_drop_get_actions (GdkDrop *self);
GDK_AVAILABLE_IN_ALL
-GdkDragContext * gdk_drop_get_drag (GdkDrop *self);
+GdkDrag * gdk_drop_get_drag (GdkDrop *self);
GDK_AVAILABLE_IN_ALL
void gdk_drop_status (GdkDrop *self,
void
_gdk_event_emit (GdkEvent *event)
{
- if (gdk_drag_context_handle_source_event (event))
+ if (gdk_drag_handle_source_event (event))
return;
if (_gdk_event_func)
*
* This function is called by the drag source.
*
- * Returns: (transfer full) (nullable): a newly created #GdkDragContext or
+ * Returns: (transfer full) (nullable): a newly created #GdkDrag or
* %NULL on error.
*/
-GdkDragContext *
+GdkDrag *
gdk_drag_begin (GdkSurface *surface,
GdkDevice *device,
GdkContentProvider *content,
gdouble opacity);
void (* destroy_notify) (GdkSurface *surface);
void (* register_dnd) (GdkSurface *surface);
- GdkDragContext * (*drag_begin) (GdkSurface *surface,
+ GdkDrag * (*drag_begin) (GdkSurface *surface,
GdkDevice *device,
GdkContentProvider*content,
GdkDragAction actions,
typedef struct _GdkCursor GdkCursor;
typedef struct _GdkTexture GdkTexture;
typedef struct _GdkDevice GdkDevice;
-typedef struct _GdkDragContext GdkDragContext;
+typedef struct _GdkDrag GdkDrag;
typedef struct _GdkDrop GdkDrop;
typedef struct _GdkClipboard GdkClipboard;
* useful if source and destination agree on what it means.
* @GDK_ACTION_ASK: Ask the user what to do with the data.
*
- * Used in #GdkDragContext to indicate what the destination
+ * Used in #GdkDrag to indicate what the destination
* should do with the dropped data.
*/
typedef enum
GdkClipboard *clipboard;
GdkClipboard *primary_clipboard;
struct wl_data_device *data_device;
- GdkDragContext *drag;
+ GdkDrag *drag;
GdkDrop *drop;
/* Source/dest for non-local dnd */
}
void
-gdk_wayland_seat_set_drag (GdkSeat *seat,
- GdkDragContext *context)
+gdk_wayland_seat_set_drag (GdkSeat *seat,
+ GdkDrag *drag)
{
GdkWaylandSeat *wayland_seat = GDK_WAYLAND_SEAT (seat);
- g_set_object (&wayland_seat->drag, context);
+ g_set_object (&wayland_seat->drag, drag);
}
struct wl_data_device *
#include <gio/gunixoutputstream.h>
#include <string.h>
-#define GDK_TYPE_WAYLAND_DRAG_CONTEXT (gdk_wayland_drag_context_get_type ())
-#define GDK_WAYLAND_DRAG_CONTEXT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WAYLAND_DRAG_CONTEXT, GdkWaylandDragContext))
-#define GDK_WAYLAND_DRAG_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WAYLAND_DRAG_CONTEXT, GdkWaylandDragContextClass))
-#define GDK_IS_WAYLAND_DRAG_CONTEXT(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WAYLAND_DRAG_CONTEXT))
-#define GDK_IS_WAYLAND_DRAG_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WAYLAND_DRAG_CONTEXT))
-#define GDK_WAYLAND_DRAG_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WAYLAND_DRAG_CONTEXT, GdkWaylandDragContextClass))
+#define GDK_TYPE_WAYLAND_DRAG (gdk_wayland_drag_get_type ())
+#define GDK_WAYLAND_DRAG(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_WAYLAND_DRAG, GdkWaylandDrag))
+#define GDK_WAYLAND_DRAG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_WAYLAND_DRAG, GdkWaylandDragClass))
+#define GDK_IS_WAYLAND_DRAG(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_WAYLAND_DRAG))
+#define GDK_IS_WAYLAND_DRAG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_WAYLAND_DRAG))
+#define GDK_WAYLAND_DRAG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_WAYLAND_DRAG, GdkWaylandDragClass))
-typedef struct _GdkWaylandDragContext GdkWaylandDragContext;
-typedef struct _GdkWaylandDragContextClass GdkWaylandDragContextClass;
+typedef struct _GdkWaylandDrag GdkWaylandDrag;
+typedef struct _GdkWaylandDragClass GdkWaylandDragClass;
-struct _GdkWaylandDragContext
+struct _GdkWaylandDrag
{
- GdkDragContext context;
+ GdkDrag drag;
GdkSurface *dnd_surface;
struct wl_surface *dnd_wl_surface;
struct wl_data_source *data_source;
gint hot_y;
};
-struct _GdkWaylandDragContextClass
+struct _GdkWaylandDragClass
{
- GdkDragContextClass parent_class;
+ GdkDragClass parent_class;
};
-static GList *contexts;
+static GList *drags;
-GType gdk_wayland_drag_context_get_type (void);
+GType gdk_wayland_drag_get_type (void);
-G_DEFINE_TYPE (GdkWaylandDragContext, gdk_wayland_drag_context, GDK_TYPE_DRAG_CONTEXT)
+G_DEFINE_TYPE (GdkWaylandDrag, gdk_wayland_drag, GDK_TYPE_DRAG)
static void
-gdk_wayland_drag_context_finalize (GObject *object)
+gdk_wayland_drag_finalize (GObject *object)
{
- GdkWaylandDragContext *wayland_context = GDK_WAYLAND_DRAG_CONTEXT (object);
- GdkDragContext *context = GDK_DRAG_CONTEXT (object);
+ GdkWaylandDrag *wayland_drag = GDK_WAYLAND_DRAG (object);
+ GdkDrag *drag = GDK_DRAG (object);
GdkSurface *dnd_surface;
- contexts = g_list_remove (contexts, context);
+ drags = g_list_remove (drags, drag);
- gdk_drag_context_set_cursor (context, NULL);
+ gdk_drag_set_cursor (drag, NULL);
- g_clear_pointer (&wayland_context->data_source, (GDestroyNotify) wl_data_source_destroy);
- g_clear_pointer (&wayland_context->offer, (GDestroyNotify) wl_data_offer_destroy);
+ g_clear_pointer (&wayland_drag->data_source, (GDestroyNotify) wl_data_source_destroy);
+ g_clear_pointer (&wayland_drag->offer, (GDestroyNotify) wl_data_offer_destroy);
- dnd_surface = wayland_context->dnd_surface;
+ dnd_surface = wayland_drag->dnd_surface;
- G_OBJECT_CLASS (gdk_wayland_drag_context_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gdk_wayland_drag_parent_class)->finalize (object);
if (dnd_surface)
gdk_surface_destroy (dnd_surface);
}
static void
-gdk_wayland_drag_context_drag_abort (GdkDragContext *context,
- guint32 time)
+gdk_wayland_drag_drag_abort (GdkDrag *drag,
+ guint32 time)
{
}
static void
-gdk_wayland_drag_context_drag_drop (GdkDragContext *context,
- guint32 time)
+gdk_wayland_drag_drag_drop (GdkDrag *drag,
+ guint32 time)
{
}
static void
-gdk_wayland_drag_context_init (GdkWaylandDragContext *context_wayland)
+gdk_wayland_drag_init (GdkWaylandDrag *drag_wayland)
{
- GdkDragContext *context;
+ GdkDrag *drag;
- context = GDK_DRAG_CONTEXT (context_wayland);
- contexts = g_list_prepend (contexts, context);
+ drag = GDK_DRAG (drag_wayland);
+ drags = g_list_prepend (drags, drag);
- context->action = GDK_ACTION_COPY;
+ drag->action = GDK_ACTION_COPY;
}
static GdkSurface *
-gdk_wayland_drag_context_get_drag_surface (GdkDragContext *context)
+gdk_wayland_drag_get_drag_surface (GdkDrag *drag)
{
- return GDK_WAYLAND_DRAG_CONTEXT (context)->dnd_surface;
+ return GDK_WAYLAND_DRAG (drag)->dnd_surface;
}
static void
-gdk_wayland_drag_context_set_hotspot (GdkDragContext *context,
- gint hot_x,
- gint hot_y)
+gdk_wayland_drag_set_hotspot (GdkDrag *drag,
+ gint hot_x,
+ gint hot_y)
{
- GdkWaylandDragContext *context_wayland = GDK_WAYLAND_DRAG_CONTEXT (context);
- gint prev_hot_x = context_wayland->hot_x;
- gint prev_hot_y = context_wayland->hot_y;
+ GdkWaylandDrag *drag_wayland = GDK_WAYLAND_DRAG (drag);
+ gint prev_hot_x = drag_wayland->hot_x;
+ gint prev_hot_y = drag_wayland->hot_y;
const GdkRectangle damage_rect = { .width = 1, .height = 1 };
- context_wayland->hot_x = hot_x;
- context_wayland->hot_y = hot_y;
+ drag_wayland->hot_x = hot_x;
+ drag_wayland->hot_y = hot_y;
if (prev_hot_x == hot_x && prev_hot_y == hot_y)
return;
- _gdk_wayland_surface_offset_next_wl_buffer (context_wayland->dnd_surface,
+ _gdk_wayland_surface_offset_next_wl_buffer (drag_wayland->dnd_surface,
-hot_x, -hot_y);
- gdk_surface_invalidate_rect (context_wayland->dnd_surface, &damage_rect);
+ gdk_surface_invalidate_rect (drag_wayland->dnd_surface, &damage_rect);
}
static void
-gdk_wayland_drag_context_set_cursor (GdkDragContext *context,
- GdkCursor *cursor)
+gdk_wayland_drag_set_cursor (GdkDrag *drag,
+ GdkCursor *cursor)
{
- GdkDevice *device = gdk_drag_context_get_device (context);
+ GdkDevice *device = gdk_drag_get_device (drag);
gdk_wayland_seat_set_global_cursor (gdk_device_get_seat (device), cursor);
}
static void
-gdk_wayland_drag_context_action_changed (GdkDragContext *context,
- GdkDragAction action)
+gdk_wayland_drag_action_changed (GdkDrag *drag,
+ GdkDragAction action)
{
GdkCursor *cursor;
- cursor = gdk_drag_get_cursor (context, action);
- gdk_drag_context_set_cursor (context, cursor);
+ cursor = gdk_drag_get_cursor (drag, action);
+ gdk_drag_set_cursor (drag, cursor);
}
static void
-gdk_wayland_drag_context_drop_performed (GdkDragContext *context,
- guint32 time_)
+gdk_wayland_drag_drop_performed (GdkDrag *drag,
+ guint32 time_)
{
- gdk_drag_context_set_cursor (context, NULL);
+ gdk_drag_set_cursor (drag, NULL);
}
static void
-gdk_wayland_drag_context_cancel (GdkDragContext *context,
- GdkDragCancelReason reason)
+gdk_wayland_drag_cancel (GdkDrag *drag,
+ GdkDragCancelReason reason)
{
- gdk_drag_context_set_cursor (context, NULL);
+ gdk_drag_set_cursor (drag, NULL);
}
static void
-gdk_wayland_drag_context_drop_done (GdkDragContext *context,
- gboolean success)
+gdk_wayland_drag_drop_done (GdkDrag *drag,
+ gboolean success)
{
- GdkWaylandDragContext *context_wayland = GDK_WAYLAND_DRAG_CONTEXT (context);
- GdkDevice *device = gdk_drag_context_get_device (context);
+ GdkWaylandDrag *drag_wayland = GDK_WAYLAND_DRAG (drag);
+ GdkDevice *device = gdk_drag_get_device (drag);
- gdk_wayland_seat_set_drag (gdk_device_get_seat (device), context);
+ gdk_wayland_seat_set_drag (gdk_device_get_seat (device), drag);
if (success)
{
- if (context_wayland->dnd_surface)
- gdk_surface_hide (context_wayland->dnd_surface);
+ if (drag_wayland->dnd_surface)
+ gdk_surface_hide (drag_wayland->dnd_surface);
}
}
static void
-gdk_wayland_drag_context_class_init (GdkWaylandDragContextClass *klass)
+gdk_wayland_drag_class_init (GdkWaylandDragClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
- GdkDragContextClass *context_class = GDK_DRAG_CONTEXT_CLASS (klass);
-
- object_class->finalize = gdk_wayland_drag_context_finalize;
-
- context_class->drag_abort = gdk_wayland_drag_context_drag_abort;
- context_class->drag_drop = gdk_wayland_drag_context_drag_drop;
- context_class->get_drag_surface = gdk_wayland_drag_context_get_drag_surface;
- context_class->set_hotspot = gdk_wayland_drag_context_set_hotspot;
- context_class->drop_done = gdk_wayland_drag_context_drop_done;
- context_class->set_cursor = gdk_wayland_drag_context_set_cursor;
- context_class->action_changed = gdk_wayland_drag_context_action_changed;
- context_class->drop_performed = gdk_wayland_drag_context_drop_performed;
- context_class->cancel = gdk_wayland_drag_context_cancel;
+ GdkDragClass *drag_class = GDK_DRAG_CLASS (klass);
+
+ object_class->finalize = gdk_wayland_drag_finalize;
+
+ drag_class->drag_abort = gdk_wayland_drag_drag_abort;
+ drag_class->drag_drop = gdk_wayland_drag_drag_drop;
+ drag_class->get_drag_surface = gdk_wayland_drag_get_drag_surface;
+ drag_class->set_hotspot = gdk_wayland_drag_set_hotspot;
+ drag_class->drop_done = gdk_wayland_drag_drop_done;
+ drag_class->set_cursor = gdk_wayland_drag_set_cursor;
+ drag_class->action_changed = gdk_wayland_drag_action_changed;
+ drag_class->drop_performed = gdk_wayland_drag_drop_performed;
+ drag_class->cancel = gdk_wayland_drag_cancel;
}
void
}
static void
-gdk_wayland_drag_context_write_done (GObject *context,
- GAsyncResult *result,
- gpointer user_data)
+gdk_wayland_drag_write_done (GObject *drag,
+ GAsyncResult *result,
+ gpointer user_data)
{
GError *error = NULL;
- if (!gdk_drag_context_write_finish (GDK_DRAG_CONTEXT (context), result, &error))
+ if (!gdk_drag_write_finish (GDK_DRAG (drag), result, &error))
{
- GDK_DISPLAY_NOTE (gdk_drag_context_get_display (GDK_DRAG_CONTEXT (context)), DND, g_message ("%p: failed to write stream: %s", context, error->message));
+ GDK_DISPLAY_NOTE (gdk_drag_get_display (GDK_DRAG (drag)), DND, g_message ("%p: failed to write stream: %s", drag, error->message));
g_error_free (error);
}
}
const char *mime_type,
int32_t fd)
{
- GdkDragContext *context = data;
+ GdkDrag *drag = data;
GOutputStream *stream;
- GDK_DISPLAY_NOTE (gdk_drag_context_get_display (context), DND, g_message ("%p: data source send request for %s on fd %d\n",
+ GDK_DISPLAY_NOTE (gdk_drag_get_display (drag), DND, g_message ("%p: data source send request for %s on fd %d\n",
source, mime_type, fd));
//mime_type = gdk_intern_mime_type (mime_type);
mime_type = g_intern_string (mime_type);
stream = g_unix_output_stream_new (fd, TRUE);
- gdk_drag_context_write_async (context,
- mime_type,
- stream,
- G_PRIORITY_DEFAULT,
- NULL,
- gdk_wayland_drag_context_write_done,
- context);
+ gdk_drag_write_async (drag,
+ mime_type,
+ stream,
+ G_PRIORITY_DEFAULT,
+ NULL,
+ gdk_wayland_drag_write_done,
+ drag);
g_object_unref (stream);
}
data_source_cancelled (void *data,
struct wl_data_source *source)
{
- GdkDragContext *context = data;
+ GdkDrag *drag = data;
- GDK_DISPLAY_NOTE (gdk_drag_context_get_display (context), EVENTS,
+ GDK_DISPLAY_NOTE (gdk_drag_get_display (drag), EVENTS,
g_message ("data source cancelled, source = %p", source));
- gdk_drag_context_cancel (context, GDK_DRAG_CANCEL_ERROR);
+ gdk_drag_cancel (drag, GDK_DRAG_CANCEL_ERROR);
}
static void
data_source_dnd_drop_performed (void *data,
struct wl_data_source *source)
{
- GdkDragContext *context = data;
+ GdkDrag *drag = data;
- g_signal_emit_by_name (context, "drop-performed");
+ g_signal_emit_by_name (drag, "drop-performed");
}
static void
data_source_dnd_finished (void *data,
struct wl_data_source *source)
{
- GdkDragContext *context = data;
+ GdkDrag *drag = data;
- g_signal_emit_by_name (context, "dnd-finished");
+ g_signal_emit_by_name (drag, "dnd-finished");
}
static void
struct wl_data_source *source,
uint32_t action)
{
- GdkDragContext *context = data;
+ GdkDrag *drag = data;
- GDK_DISPLAY_NOTE (gdk_drag_context_get_display (context), EVENTS,
+ GDK_DISPLAY_NOTE (gdk_drag_get_display (drag), EVENTS,
g_message ("data source action, source = %p action=%x",
source, action));
- context->action = _wl_to_gdk_actions (action);
- g_signal_emit_by_name (context, "action-changed", context->action);
+ drag->action = _wl_to_gdk_actions (action);
+ g_signal_emit_by_name (drag, "action-changed", drag->action);
}
static const struct wl_data_source_listener data_source_listener = {
};
static void
-gdk_wayland_drag_context_create_data_source (GdkDragContext *context)
+gdk_wayland_drag_create_data_source (GdkDrag *drag)
{
- GdkWaylandDragContext *context_wayland = GDK_WAYLAND_DRAG_CONTEXT (context);
- GdkDisplay *display = gdk_drag_context_get_display (context);
+ GdkWaylandDrag *drag_wayland = GDK_WAYLAND_DRAG (drag);
+ GdkDisplay *display = gdk_drag_get_display (drag);
GdkWaylandDisplay *display_wayland = GDK_WAYLAND_DISPLAY (display);
const char *const *mimetypes;
gsize i, n_mimetypes;
- context_wayland->data_source = wl_data_device_manager_create_data_source (display_wayland->data_device_manager);
- wl_data_source_add_listener (context_wayland->data_source,
+ drag_wayland->data_source = wl_data_device_manager_create_data_source (display_wayland->data_device_manager);
+ wl_data_source_add_listener (drag_wayland->data_source,
&data_source_listener,
- context);
+ drag);
- mimetypes = gdk_content_formats_get_mime_types (gdk_drag_context_get_formats (context), &n_mimetypes);
+ mimetypes = gdk_content_formats_get_mime_types (gdk_drag_get_formats (drag), &n_mimetypes);
for (i = 0; i < n_mimetypes; i++)
{
- wl_data_source_offer (context_wayland->data_source, mimetypes[i]);
+ wl_data_source_offer (drag_wayland->data_source, mimetypes[i]);
}
}
-GdkDragContext *
+GdkDrag *
_gdk_wayland_surface_drag_begin (GdkSurface *surface,
GdkDevice *device,
GdkContentProvider *content,
gint dx,
gint dy)
{
- GdkWaylandDragContext *context_wayland;
- GdkDragContext *context;
+ GdkWaylandDrag *drag_wayland;
+ GdkDrag *drag;
GdkSeat *seat;
GdkWaylandDisplay *display_wayland;
display_wayland = GDK_WAYLAND_DISPLAY (gdk_device_get_display (device));
seat = gdk_device_get_seat (device);
- context_wayland = g_object_new (GDK_TYPE_WAYLAND_DRAG_CONTEXT,
- "device", device,
- "content", content,
- NULL);
- context = GDK_DRAG_CONTEXT (context_wayland);
- context->source_surface = g_object_ref (surface);
+ drag_wayland = g_object_new (GDK_TYPE_WAYLAND_DRAG,
+ "device", device,
+ "content", content,
+ NULL);
+ drag = GDK_DRAG (drag_wayland);
+ drag->source_surface = g_object_ref (surface);
- context_wayland->dnd_surface = create_dnd_surface (gdk_surface_get_display (surface));
- context_wayland->dnd_wl_surface = gdk_wayland_surface_get_wl_surface (context_wayland->dnd_surface);
+ drag_wayland->dnd_surface = create_dnd_surface (gdk_surface_get_display (surface));
+ drag_wayland->dnd_wl_surface = gdk_wayland_surface_get_wl_surface (drag_wayland->dnd_surface);
- gdk_wayland_drag_context_create_data_source (context);
+ gdk_wayland_drag_create_data_source (drag);
if (display_wayland->data_device_manager_version >=
WL_DATA_SOURCE_SET_ACTIONS_SINCE_VERSION)
{
- wl_data_source_set_actions (context_wayland->data_source,
+ wl_data_source_set_actions (drag_wayland->data_source,
gdk_to_wl_actions (actions));
}
- gdk_wayland_seat_set_drag (seat, context);
+ gdk_wayland_seat_set_drag (seat, drag);
wl_data_device_start_drag (gdk_wayland_device_get_data_device (device),
- context_wayland->data_source,
+ drag_wayland->data_source,
gdk_wayland_surface_get_wl_surface (surface),
- context_wayland->dnd_wl_surface,
+ drag_wayland->dnd_wl_surface,
_gdk_wayland_display_get_serial (display_wayland));
gdk_seat_ungrab (seat);
- return context;
+ return drag;
}
void
-_gdk_wayland_drag_context_set_source_surface (GdkDragContext *context,
- GdkSurface *surface)
+_gdk_wayland_drag_set_source_surface (GdkDrag *drag,
+ GdkSurface *surface)
{
- if (context->source_surface)
- g_object_unref (context->source_surface);
+ if (drag->source_surface)
+ g_object_unref (drag->source_surface);
- context->source_surface = surface ? g_object_ref (surface) : NULL;
+ drag->source_surface = surface ? g_object_ref (surface) : NULL;
}
GdkDrop *
gdk_wayland_drop_new (GdkDevice *device,
- GdkDragContext *drag,
+ GdkDrag *drag,
GdkContentFormats *formats,
GdkSurface *surface,
struct wl_data_offer *offer,
const cairo_region_t *damage);
void _gdk_wayland_surface_register_dnd (GdkSurface *surface);
-GdkDragContext *_gdk_wayland_surface_drag_begin (GdkSurface *surface,
+GdkDrag *_gdk_wayland_surface_drag_begin (GdkSurface *surface,
GdkDevice *device,
GdkContentProvider *content,
GdkDragAction actions,
int x,
int y);
GdkDrop * gdk_wayland_drop_new (GdkDevice *device,
- GdkDragContext *drag,
+ GdkDrag *drag,
GdkContentFormats *formats,
GdkSurface *surface,
struct wl_data_offer *offer,
void gdk_wayland_drop_set_action (GdkDrop *drop,
uint32_t action);
-void _gdk_wayland_drag_context_set_source_surface (GdkDragContext *context,
- GdkSurface *surface);
+void _gdk_wayland_drag_set_source_surface (GdkDrag *drag,
+ GdkSurface *surface);
-void _gdk_wayland_display_create_surface_impl (GdkDisplay *display,
- GdkSurface *surface,
- GdkSurface *real_parent,
- GdkSurfaceAttr *attributes);
+void _gdk_wayland_display_create_surface_impl (GdkDisplay *display,
+ GdkSurface *surface,
+ GdkSurface *real_parent,
+ GdkSurfaceAttr *attributes);
gint _gdk_wayland_display_text_property_to_utf8_list (GdkDisplay *display,
GdkAtom encoding,
void gdk_wayland_device_set_selection (GdkDevice *gdk_device,
struct wl_data_source *source);
-GdkDragContext * gdk_wayland_device_get_drop_context (GdkDevice *gdk_device);
+GdkDrag* gdk_wayland_device_get_drop_context (GdkDevice *gdk_device);
void gdk_wayland_device_unset_touch_grab (GdkDevice *device,
GdkEventSequence *sequence);
void gdk_wayland_seat_set_global_cursor (GdkSeat *seat,
GdkCursor *cursor);
void gdk_wayland_seat_set_drag (GdkSeat *seat,
- GdkDragContext *drag);
+ GdkDrag *drag);
struct wl_output *gdk_wayland_surface_get_wl_output (GdkSurface *surface);
* @GDK_DRAG_PROTO_ROOTWIN: An extension to the Xdnd protocol for
* unclaimed root window drops.
*
- * Used in #GdkDragContext to indicate the protocol according to
+ * Used in #GdkDrag to indicate the protocol according to
* which DND is done.
*/
typedef enum
};
-struct _GdkX11DragContext
+struct _GdkX11Drag
{
- GdkDragContext context;
+ GdkDrag drag;
GdkDragProtocol protocol;
guint drop_failed : 1; /* Whether the drop was unsuccessful */
};
-struct _GdkX11DragContextClass
+struct _GdkX11DragClass
{
- GdkDragContextClass parent_class;
+ GdkDragClass parent_class;
};
typedef struct {
static GdkSurfaceCache *gdk_surface_cache_ref (GdkSurfaceCache *cache);
static void gdk_surface_cache_unref (GdkSurfaceCache *cache);
-gboolean gdk_x11_drag_context_handle_event (GdkDragContext *context,
- const GdkEvent *event);
-void gdk_x11_drag_context_action_changed (GdkDragContext *context,
- GdkDragAction action);
+gboolean gdk_x11_drag_handle_event (GdkDrag *drag,
+ const GdkEvent *event);
+void gdk_x11_drag_action_changed (GdkDrag *drag,
+ GdkDragAction action);
-static GList *contexts;
+static GList *drags;
static GSList *window_caches;
-G_DEFINE_TYPE (GdkX11DragContext, gdk_x11_drag_context, GDK_TYPE_DRAG_CONTEXT)
+G_DEFINE_TYPE (GdkX11Drag, gdk_x11_drag, GDK_TYPE_DRAG)
static void
-gdk_x11_drag_context_init (GdkX11DragContext *context)
-{
- contexts = g_list_prepend (contexts, context);
-}
-
-static void gdk_x11_drag_context_finalize (GObject *object);
-static Window gdk_x11_drag_context_find_surface (GdkDragContext *context,
- GdkSurface *drag_surface,
- gint x_root,
- gint y_root,
- GdkDragProtocol *protocol);
-static gboolean gdk_x11_drag_context_drag_motion (GdkDragContext *context,
- Window proxy_xid,
- GdkDragProtocol protocol,
- gint x_root,
- gint y_root,
- GdkDragAction suggested_action,
- GdkDragAction possible_actions,
- guint32 time);
-static void gdk_x11_drag_context_drag_abort (GdkDragContext *context,
- guint32 time_);
-static void gdk_x11_drag_context_drag_drop (GdkDragContext *context,
- guint32 time_);
-static GdkSurface * gdk_x11_drag_context_get_drag_surface (GdkDragContext *context);
-static void gdk_x11_drag_context_set_hotspot (GdkDragContext *context,
- gint hot_x,
- gint hot_y);
-static void gdk_x11_drag_context_drop_done (GdkDragContext *context,
- gboolean success);
-static void gdk_x11_drag_context_set_cursor (GdkDragContext *context,
- GdkCursor *cursor);
-static void gdk_x11_drag_context_cancel (GdkDragContext *context,
- GdkDragCancelReason reason);
-static void gdk_x11_drag_context_drop_performed (GdkDragContext *context,
- guint32 time);
+gdk_x11_drag_init (GdkX11Drag *drag)
+{
+ drags = g_list_prepend (drags, drag);
+}
+
+static void gdk_x11_drag_finalize (GObject *object);
+static Window gdk_x11_drag_find_surface (GdkDrag *drag,
+ GdkSurface *drag_surface,
+ gint x_root,
+ gint y_root,
+ GdkDragProtocol *protocol);
+static gboolean gdk_x11_drag_drag_motion (GdkDrag *drag,
+ Window proxy_xid,
+ GdkDragProtocol protocol,
+ gint x_root,
+ gint y_root,
+ GdkDragAction suggested_action,
+ GdkDragAction possible_actions,
+ guint32 time);
+static void gdk_x11_drag_drag_abort (GdkDrag *drag,
+ guint32 time_);
+static void gdk_x11_drag_drag_drop (GdkDrag *drag,
+ guint32 time_);
+static GdkSurface * gdk_x11_drag_get_drag_surface (GdkDrag *drag);
+static void gdk_x11_drag_set_hotspot (GdkDrag *drag,
+ gint hot_x,
+ gint hot_y);
+static void gdk_x11_drag_drop_done (GdkDrag *drag,
+ gboolean success);
+static void gdk_x11_drag_set_cursor (GdkDrag *drag,
+ GdkCursor *cursor);
+static void gdk_x11_drag_cancel (GdkDrag *drag,
+ GdkDragCancelReason reason);
+static void gdk_x11_drag_drop_performed (GdkDrag *drag,
+ guint32 time);
static void
-gdk_x11_drag_context_class_init (GdkX11DragContextClass *klass)
+gdk_x11_drag_class_init (GdkX11DragClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
- GdkDragContextClass *context_class = GDK_DRAG_CONTEXT_CLASS (klass);
+ GdkDragClass *drag_class = GDK_DRAG_CLASS (klass);
- object_class->finalize = gdk_x11_drag_context_finalize;
+ object_class->finalize = gdk_x11_drag_finalize;
- context_class->drag_abort = gdk_x11_drag_context_drag_abort;
- context_class->drag_drop = gdk_x11_drag_context_drag_drop;
- context_class->get_drag_surface = gdk_x11_drag_context_get_drag_surface;
- context_class->set_hotspot = gdk_x11_drag_context_set_hotspot;
- context_class->drop_done = gdk_x11_drag_context_drop_done;
- context_class->set_cursor = gdk_x11_drag_context_set_cursor;
- context_class->cancel = gdk_x11_drag_context_cancel;
- context_class->drop_performed = gdk_x11_drag_context_drop_performed;
- context_class->handle_event = gdk_x11_drag_context_handle_event;
- context_class->action_changed = gdk_x11_drag_context_action_changed;
+ drag_class->drag_abort = gdk_x11_drag_drag_abort;
+ drag_class->drag_drop = gdk_x11_drag_drag_drop;
+ drag_class->get_drag_surface = gdk_x11_drag_get_drag_surface;
+ drag_class->set_hotspot = gdk_x11_drag_set_hotspot;
+ drag_class->drop_done = gdk_x11_drag_drop_done;
+ drag_class->set_cursor = gdk_x11_drag_set_cursor;
+ drag_class->cancel = gdk_x11_drag_cancel;
+ drag_class->drop_performed = gdk_x11_drag_drop_performed;
+ drag_class->handle_event = gdk_x11_drag_handle_event;
+ drag_class->action_changed = gdk_x11_drag_action_changed;
}
static void
-gdk_x11_drag_context_finalize (GObject *object)
+gdk_x11_drag_finalize (GObject *object)
{
- GdkDragContext *context = GDK_DRAG_CONTEXT (object);
- GdkX11DragContext *x11_context = GDK_X11_DRAG_CONTEXT (object);
+ GdkDrag *drag = GDK_DRAG (object);
+ GdkX11Drag *x11_drag = GDK_X11_DRAG (object);
GdkSurface *drag_surface, *ipc_surface;
- if (x11_context->cache)
- gdk_surface_cache_unref (x11_context->cache);
+ if (x11_drag->cache)
+ gdk_surface_cache_unref (x11_drag->cache);
- contexts = g_list_remove (contexts, context);
+ drags = g_list_remove (drags, drag);
- drag_surface = context->drag_surface;
- ipc_surface = x11_context->ipc_surface;
+ drag_surface = drag->drag_surface;
+ ipc_surface = x11_drag->ipc_surface;
- G_OBJECT_CLASS (gdk_x11_drag_context_parent_class)->finalize (object);
+ G_OBJECT_CLASS (gdk_x11_drag_parent_class)->finalize (object);
if (drag_surface)
gdk_surface_destroy (drag_surface);
/* Drag Contexts */
-GdkDragContext *
-gdk_x11_drag_context_find (GdkDisplay *display,
- Window source_xid,
- Window dest_xid)
+GdkDrag *
+gdk_x11_drag_find (GdkDisplay *display,
+ Window source_xid,
+ Window dest_xid)
{
GList *tmp_list;
- GdkDragContext *context;
- GdkX11DragContext *context_x11;
- Window context_dest_xid;
+ GdkDrag *drag;
+ GdkX11Drag *drag_x11;
+ Window drag_dest_xid;
- for (tmp_list = contexts; tmp_list; tmp_list = tmp_list->next)
+ for (tmp_list = drags; tmp_list; tmp_list = tmp_list->next)
{
- context = (GdkDragContext *)tmp_list->data;
- context_x11 = (GdkX11DragContext *)context;
+ drag = (GdkDrag *)tmp_list->data;
+ drag_x11 = (GdkX11Drag *)drag;
- if (gdk_drag_context_get_display (context) != display)
+ if (gdk_drag_get_display (drag) != display)
continue;
- context_dest_xid = context_x11->proxy_xid
- ? (context_x11->drop_xid
- ? context_x11->drop_xid
- : context_x11->proxy_xid)
+ drag_dest_xid = drag_x11->proxy_xid
+ ? (drag_x11->drop_xid
+ ? drag_x11->drop_xid
+ : drag_x11->proxy_xid)
: None;
- if (((source_xid == None) || (context->source_surface &&
- (GDK_SURFACE_XID (context->source_surface) == source_xid))) &&
- ((dest_xid == None) || (context_dest_xid == dest_xid)))
- return context;
+ if (((source_xid == None) || (drag->source_surface &&
+ (GDK_SURFACE_XID (drag->source_surface) == source_xid))) &&
+ ((dest_xid == None) || (drag_dest_xid == dest_xid)))
+ return drag;
}
return NULL;
}
static void
-precache_target_list (GdkDragContext *context)
+precache_target_list (GdkDrag *drag)
{
- GdkContentFormats *formats = gdk_drag_context_get_formats (context);
+ GdkContentFormats *formats = gdk_drag_get_formats (drag);
const char * const *atoms;
gsize n_atoms;
atoms = gdk_content_formats_get_mime_types (formats, &n_atoms);
- _gdk_x11_precache_atoms (gdk_drag_context_get_display (context),
+ _gdk_x11_precache_atoms (gdk_drag_get_display (drag),
(const gchar **) atoms,
n_atoms);
}
static void
gdk_surface_cache_add (GdkSurfaceCache *cache,
- guint32 xid,
- gint x,
- gint y,
- gint width,
- gint height,
- gboolean mapped)
-{
+ guint32 xid,
+ gint x,
+ gint y,
+ gint width,
+ gint height,
+ gboolean mapped)
+{
GdkCacheChild *child = g_new (GdkCacheChild, 1);
child->xid = xid;
GdkFilterReturn
gdk_surface_cache_shape_filter (const XEvent *xevent,
- GdkEvent *event,
- gpointer data)
+ GdkEvent *event,
+ gpointer data)
{
GdkSurfaceCache *cache = data;
GdkFilterReturn
gdk_surface_cache_filter (const XEvent *xevent,
- GdkEvent *event,
- gpointer data)
+ GdkEvent *event,
+ gpointer data)
{
GdkSurfaceCache *cache = data;
/* Source side */
void
-gdk_x11_drag_context_handle_status (GdkDisplay *display,
- const XEvent *xevent)
+gdk_x11_drag_handle_status (GdkDisplay *display,
+ const XEvent *xevent)
{
guint32 dest_surface = xevent->xclient.data.l[0];
guint32 flags = xevent->xclient.data.l[1];
Atom action = xevent->xclient.data.l[4];
- GdkDragContext *context;
+ GdkDrag *drag;
- context = gdk_x11_drag_context_find (display, xevent->xclient.window, dest_surface);
+ drag = gdk_x11_drag_find (display, xevent->xclient.window, dest_surface);
GDK_DISPLAY_NOTE (display, DND,
g_message ("XdndStatus: dest_surface: %#x action: %ld",
dest_surface, action));
- if (context)
+ if (drag)
{
- GdkX11DragContext *context_x11 = GDK_X11_DRAG_CONTEXT (context);
- if (context_x11->drag_status == GDK_DRAG_STATUS_MOTION_WAIT)
- context_x11->drag_status = GDK_DRAG_STATUS_DRAG;
+ GdkX11Drag *drag_x11 = GDK_X11_DRAG (drag);
+ if (drag_x11->drag_status == GDK_DRAG_STATUS_MOTION_WAIT)
+ drag_x11->drag_status = GDK_DRAG_STATUS_DRAG;
if (!(action != 0) != !(flags & 1))
{
action = 0;
}
- context->action = xdnd_action_from_atom (display, action);
+ drag->action = xdnd_action_from_atom (display, action);
- if (context->action != context_x11->current_action)
+ if (drag->action != drag_x11->current_action)
{
- context_x11->current_action = context->action;
- g_signal_emit_by_name (context, "action-changed", context->action);
+ drag_x11->current_action = drag->action;
+ g_signal_emit_by_name (drag, "action-changed", drag->action);
}
}
}
void
-gdk_x11_drag_context_handle_finished (GdkDisplay *display,
- const XEvent *xevent)
+gdk_x11_drag_handle_finished (GdkDisplay *display,
+ const XEvent *xevent)
{
guint32 dest_surface = xevent->xclient.data.l[0];
- GdkDragContext *context;
- GdkX11DragContext *context_x11;
+ GdkDrag *drag;
+ GdkX11Drag *drag_x11;
- context = gdk_x11_drag_context_find (display, xevent->xclient.window, dest_surface);
+ drag = gdk_x11_drag_find (display, xevent->xclient.window, dest_surface);
GDK_DISPLAY_NOTE (display, DND,
g_message ("XdndFinished: dest_surface: %#x", dest_surface));
- if (context)
+ if (drag)
{
- g_object_ref (context);
+ g_object_ref (drag);
- context_x11 = GDK_X11_DRAG_CONTEXT (context);
- if (context_x11->version == 5)
- context_x11->drop_failed = xevent->xclient.data.l[1] == 0;
+ drag_x11 = GDK_X11_DRAG (drag);
+ if (drag_x11->version == 5)
+ drag_x11->drop_failed = xevent->xclient.data.l[1] == 0;
- g_signal_emit_by_name (context, "dnd-finished");
- gdk_drag_drop_done (context, !context_x11->drop_failed);
+ g_signal_emit_by_name (drag, "dnd-finished");
+ gdk_drag_drop_done (drag, !drag_x11->drop_failed);
- g_object_unref (context);
+ g_object_unref (drag);
}
}
static void
-xdnd_set_targets (GdkX11DragContext *context_x11)
+xdnd_set_targets (GdkX11Drag *drag_x11)
{
- GdkDragContext *context = GDK_DRAG_CONTEXT (context_x11);
+ GdkDrag *drag = GDK_DRAG (drag_x11);
Atom *atomlist;
const char * const *atoms;
gsize i, n_atoms;
- GdkDisplay *display = gdk_drag_context_get_display (context);
+ GdkDisplay *display = gdk_drag_get_display (drag);
- atoms = gdk_content_formats_get_mime_types (gdk_drag_context_get_formats (context), &n_atoms);
+ atoms = gdk_content_formats_get_mime_types (gdk_drag_get_formats (drag), &n_atoms);
atomlist = g_new (Atom, n_atoms);
for (i = 0; i < n_atoms; i++)
atomlist[i] = gdk_x11_get_xatom_by_name_for_display (display, atoms[i]);
XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
- GDK_SURFACE_XID (context_x11->ipc_surface),
+ GDK_SURFACE_XID (drag_x11->ipc_surface),
gdk_x11_get_xatom_by_name_for_display (display, "XdndTypeList"),
XA_ATOM, 32, PropModeReplace,
(guchar *)atomlist, n_atoms);
g_free (atomlist);
- context_x11->xdnd_targets_set = 1;
+ drag_x11->xdnd_targets_set = 1;
}
static void
-xdnd_set_actions (GdkX11DragContext *context_x11)
+xdnd_set_actions (GdkX11Drag *drag_x11)
{
- GdkDragContext *context = GDK_DRAG_CONTEXT (context_x11);
+ GdkDrag *drag = GDK_DRAG (drag_x11);
Atom *atomlist;
gint i;
gint n_atoms;
guint actions;
- GdkDisplay *display = gdk_drag_context_get_display (context);
+ GdkDisplay *display = gdk_drag_get_display (drag);
- actions = gdk_drag_context_get_actions (context);
+ actions = gdk_drag_get_actions (drag);
n_atoms = 0;
for (i = 0; i < xdnd_n_actions; i++)
{
atomlist = g_new (Atom, n_atoms);
- actions = gdk_drag_context_get_actions (context);
+ actions = gdk_drag_get_actions (drag);
n_atoms = 0;
for (i = 0; i < xdnd_n_actions; i++)
{
}
XChangeProperty (GDK_DISPLAY_XDISPLAY (display),
- GDK_SURFACE_XID (context_x11->ipc_surface),
+ GDK_SURFACE_XID (drag_x11->ipc_surface),
gdk_x11_get_xatom_by_name_for_display (display, "XdndActionList"),
XA_ATOM, 32, PropModeReplace,
(guchar *)atomlist, n_atoms);
g_free (atomlist);
- context_x11->xdnd_actions = gdk_drag_context_get_actions (context);
+ drag_x11->xdnd_actions = gdk_drag_get_actions (drag);
}
static void
gboolean success,
gpointer data)
{
- GdkX11DragContext *context_x11 = data;
- GdkDragContext *context = data;
+ GdkX11Drag *drag_x11 = data;
+ GdkDrag *drag = data;
- GDK_DISPLAY_NOTE (gdk_drag_context_get_display (context), DND,
+ GDK_DISPLAY_NOTE (gdk_drag_get_display (drag), DND,
g_message ("Got async callback for #%lx, success = %d",
window, success));
* so we don't end up blocking for a timeout
*/
if (!success &&
- window == context_x11->proxy_xid)
+ window == drag_x11->proxy_xid)
{
- context_x11->proxy_xid = None;
- context->action = 0;
- if (context->action != context_x11->current_action)
+ drag_x11->proxy_xid = None;
+ drag->action = 0;
+ if (drag->action != drag_x11->current_action)
{
- context_x11->current_action = 0;
- g_signal_emit_by_name (context, "action-changed", 0);
+ drag_x11->current_action = 0;
+ g_signal_emit_by_name (drag, "action-changed", 0);
}
- context_x11->drag_status = GDK_DRAG_STATUS_DRAG;
+ drag_x11->drag_status = GDK_DRAG_STATUS_DRAG;
}
- g_object_unref (context);
+ g_object_unref (drag);
}
static void
-send_client_message_async (GdkDragContext *context,
+send_client_message_async (GdkDrag *drag,
Window window,
glong event_mask,
XClientMessageEvent *event_send)
{
- GdkDisplay *display = gdk_drag_context_get_display (context);
+ GdkDisplay *display = gdk_drag_get_display (drag);
- g_object_ref (context);
+ g_object_ref (drag);
_gdk_x11_send_client_message_async (display, window,
FALSE, event_mask, event_send,
- send_client_message_async_cb, context);
+ send_client_message_async_cb, drag);
}
static void
-xdnd_send_xevent (GdkX11DragContext *context_x11,
+xdnd_send_xevent (GdkX11Drag *drag_x11,
XEvent *event_send)
{
- GdkDragContext *context = GDK_DRAG_CONTEXT (context_x11);
- GdkDisplay *display = gdk_drag_context_get_display (context);
+ GdkDrag *drag = GDK_DRAG (drag_x11);
+ GdkDisplay *display = gdk_drag_get_display (drag);
GdkSurface *surface;
glong event_mask;
g_assert (event_send->xany.type == ClientMessage);
/* We short-circuit messages to ourselves */
- surface = gdk_x11_surface_lookup_for_display (display, context_x11->proxy_xid);
+ surface = gdk_x11_surface_lookup_for_display (display, drag_x11->proxy_xid);
if (surface)
{
if (gdk_x11_drop_filter (surface, event_send))
return;
}
- if (_gdk_x11_display_is_root_window (display, context_x11->proxy_xid))
+ if (_gdk_x11_display_is_root_window (display, drag_x11->proxy_xid))
event_mask = ButtonPressMask;
else
event_mask = 0;
- send_client_message_async (context, context_x11->proxy_xid, event_mask,
+ send_client_message_async (drag, drag_x11->proxy_xid, event_mask,
&event_send->xclient);
}
static void
-xdnd_send_enter (GdkX11DragContext *context_x11)
+xdnd_send_enter (GdkX11Drag *drag_x11)
{
- GdkDragContext *context = GDK_DRAG_CONTEXT (context_x11);
- GdkDisplay *display = gdk_drag_context_get_display (context);
+ GdkDrag *drag = GDK_DRAG (drag_x11);
+ GdkDisplay *display = gdk_drag_get_display (drag);
const char * const *atoms;
gsize i, n_atoms;
XEvent xev;
xev.xclient.type = ClientMessage;
xev.xclient.message_type = gdk_x11_get_xatom_by_name_for_display (display, "XdndEnter");
xev.xclient.format = 32;
- xev.xclient.window = context_x11->drop_xid
- ? context_x11->drop_xid
- : context_x11->proxy_xid;
- xev.xclient.data.l[0] = GDK_SURFACE_XID (context_x11->ipc_surface);
- xev.xclient.data.l[1] = (context_x11->version << 24); /* version */
+ xev.xclient.window = drag_x11->drop_xid
+ ? drag_x11->drop_xid
+ : drag_x11->proxy_xid;
+ xev.xclient.data.l[0] = GDK_SURFACE_XID (drag_x11->ipc_surface);
+ xev.xclient.data.l[1] = (drag_x11->version << 24); /* version */
xev.xclient.data.l[2] = 0;
xev.xclient.data.l[3] = 0;
xev.xclient.data.l[4] = 0;
GDK_DISPLAY_NOTE (display, DND,
g_message ("Sending enter source window %#lx XDND protocol version %d\n",
- GDK_SURFACE_XID (context_x11->ipc_surface), context_x11->version));
- atoms = gdk_content_formats_get_mime_types (gdk_drag_context_get_formats (context), &n_atoms);
+ GDK_SURFACE_XID (drag_x11->ipc_surface), drag_x11->version));
+ atoms = gdk_content_formats_get_mime_types (gdk_drag_get_formats (drag), &n_atoms);
if (n_atoms > 3)
{
- if (!context_x11->xdnd_targets_set)
- xdnd_set_targets (context_x11);
+ if (!drag_x11->xdnd_targets_set)
+ xdnd_set_targets (drag_x11);
xev.xclient.data.l[1] |= 1;
}
else
}
}
- xdnd_send_xevent (context_x11, &xev);
+ xdnd_send_xevent (drag_x11, &xev);
}
static void
-xdnd_send_leave (GdkX11DragContext *context_x11)
+xdnd_send_leave (GdkX11Drag *drag_x11)
{
- GdkDragContext *context = GDK_DRAG_CONTEXT (context_x11);
- GdkDisplay *display = gdk_drag_context_get_display (context);
+ GdkDrag *drag = GDK_DRAG (drag_x11);
+ GdkDisplay *display = gdk_drag_get_display (drag);
XEvent xev;
xev.xclient.type = ClientMessage;
xev.xclient.message_type = gdk_x11_get_xatom_by_name_for_display (display, "XdndLeave");
xev.xclient.format = 32;
- xev.xclient.window = context_x11->drop_xid
- ? context_x11->drop_xid
- : context_x11->proxy_xid;
- xev.xclient.data.l[0] = GDK_SURFACE_XID (context_x11->ipc_surface);
+ xev.xclient.window = drag_x11->drop_xid
+ ? drag_x11->drop_xid
+ : drag_x11->proxy_xid;
+ xev.xclient.data.l[0] = GDK_SURFACE_XID (drag_x11->ipc_surface);
xev.xclient.data.l[1] = 0;
xev.xclient.data.l[2] = 0;
xev.xclient.data.l[3] = 0;
xev.xclient.data.l[4] = 0;
- xdnd_send_xevent (context_x11, &xev);
+ xdnd_send_xevent (drag_x11, &xev);
}
static void
-xdnd_send_drop (GdkX11DragContext *context_x11,
+xdnd_send_drop (GdkX11Drag *drag_x11,
guint32 time)
{
- GdkDragContext *context = GDK_DRAG_CONTEXT (context_x11);
- GdkDisplay *display = gdk_drag_context_get_display (context);
+ GdkDrag *drag = GDK_DRAG (drag_x11);
+ GdkDisplay *display = gdk_drag_get_display (drag);
XEvent xev;
xev.xclient.type = ClientMessage;
xev.xclient.message_type = gdk_x11_get_xatom_by_name_for_display (display, "XdndDrop");
xev.xclient.format = 32;
- xev.xclient.window = context_x11->drop_xid
- ? context_x11->drop_xid
- : context_x11->proxy_xid;
- xev.xclient.data.l[0] = GDK_SURFACE_XID (context_x11->ipc_surface);
+ xev.xclient.window = drag_x11->drop_xid
+ ? drag_x11->drop_xid
+ : drag_x11->proxy_xid;
+ xev.xclient.data.l[0] = GDK_SURFACE_XID (drag_x11->ipc_surface);
xev.xclient.data.l[1] = 0;
xev.xclient.data.l[2] = time;
xev.xclient.data.l[3] = 0;
xev.xclient.data.l[4] = 0;
- xdnd_send_xevent (context_x11, &xev);
+ xdnd_send_xevent (drag_x11, &xev);
}
static void
-xdnd_send_motion (GdkX11DragContext *context_x11,
+xdnd_send_motion (GdkX11Drag *drag_x11,
gint x_root,
gint y_root,
GdkDragAction action,
guint32 time)
{
- GdkDragContext *context = GDK_DRAG_CONTEXT (context_x11);
- GdkDisplay *display = gdk_drag_context_get_display (context);
+ GdkDrag *drag = GDK_DRAG (drag_x11);
+ GdkDisplay *display = gdk_drag_get_display (drag);
XEvent xev;
xev.xclient.type = ClientMessage;
xev.xclient.message_type = gdk_x11_get_xatom_by_name_for_display (display, "XdndPosition");
xev.xclient.format = 32;
- xev.xclient.window = context_x11->drop_xid
- ? context_x11->drop_xid
- : context_x11->proxy_xid;
- xev.xclient.data.l[0] = GDK_SURFACE_XID (context_x11->ipc_surface);
+ xev.xclient.window = drag_x11->drop_xid
+ ? drag_x11->drop_xid
+ : drag_x11->proxy_xid;
+ xev.xclient.data.l[0] = GDK_SURFACE_XID (drag_x11->ipc_surface);
xev.xclient.data.l[1] = 0;
xev.xclient.data.l[2] = (x_root << 16) | y_root;
xev.xclient.data.l[3] = time;
xev.xclient.data.l[4] = xdnd_action_to_atom (display, action);
- xdnd_send_xevent (context_x11, &xev);
- context_x11->drag_status = GDK_DRAG_STATUS_MOTION_WAIT;
+ xdnd_send_xevent (drag_x11, &xev);
+ drag_x11->drag_status = GDK_DRAG_STATUS_MOTION_WAIT;
}
static guint32
/* Source side */
static void
-gdk_drag_do_leave (GdkX11DragContext *context_x11,
+gdk_drag_do_leave (GdkX11Drag *drag_x11,
guint32 time)
{
- if (context_x11->proxy_xid)
+ if (drag_x11->proxy_xid)
{
- switch (context_x11->protocol)
+ switch (drag_x11->protocol)
{
case GDK_DRAG_PROTO_XDND:
- xdnd_send_leave (context_x11);
+ xdnd_send_leave (drag_x11);
break;
case GDK_DRAG_PROTO_ROOTWIN:
case GDK_DRAG_PROTO_NONE:
break;
}
- context_x11->proxy_xid = None;
+ drag_x11->proxy_xid = None;
}
}
}
static GdkSurfaceCache *
-drag_context_find_window_cache (GdkX11DragContext *context_x11,
+drag_find_window_cache (GdkX11Drag *drag_x11,
GdkDisplay *display)
{
- if (!context_x11->cache)
- context_x11->cache = gdk_surface_cache_get (display);
+ if (!drag_x11->cache)
+ drag_x11->cache = gdk_surface_cache_get (display);
- return context_x11->cache;
+ return drag_x11->cache;
}
static Window
-gdk_x11_drag_context_find_surface (GdkDragContext *context,
+gdk_x11_drag_find_surface (GdkDrag *drag,
GdkSurface *drag_surface,
gint x_root,
gint y_root,
GdkDragProtocol *protocol)
{
GdkX11Screen *screen_x11;
- GdkX11DragContext *context_x11 = GDK_X11_DRAG_CONTEXT (context);
+ GdkX11Drag *drag_x11 = GDK_X11_DRAG (drag);
GdkSurfaceCache *window_cache;
GdkDisplay *display;
Window dest;
Window proxy;
- display = gdk_drag_context_get_display (context);
+ display = gdk_drag_get_display (drag);
screen_x11 = GDK_X11_SCREEN(GDK_X11_DISPLAY (display)->screen);
- window_cache = drag_context_find_window_cache (context_x11, display);
+ window_cache = drag_find_window_cache (drag_x11, display);
dest = get_client_window_at_coords (window_cache,
drag_surface && GDK_SURFACE_IS_X11 (drag_surface) ?
x_root * screen_x11->surface_scale,
y_root * screen_x11->surface_scale);
- if (context_x11->dest_xid != dest)
+ if (drag_x11->dest_xid != dest)
{
- context_x11->dest_xid = dest;
+ drag_x11->dest_xid = dest;
/* Check if new destination accepts drags, and which protocol */
proxy = _gdk_x11_display_get_drag_protocol (display,
dest,
protocol,
- &context_x11->version);
+ &drag_x11->version);
}
else
{
proxy = dest;
- *protocol = context_x11->protocol;
+ *protocol = drag_x11->protocol;
}
return proxy;
}
static void
-move_drag_surface (GdkDragContext *context,
+move_drag_surface (GdkDrag *drag,
guint x_root,
guint y_root)
{
- GdkX11DragContext *context_x11 = GDK_X11_DRAG_CONTEXT (context);
+ GdkX11Drag *drag_x11 = GDK_X11_DRAG (drag);
- gdk_surface_move (context_x11->drag_surface,
- x_root - context_x11->hot_x,
- y_root - context_x11->hot_y);
- gdk_surface_raise (context_x11->drag_surface);
+ gdk_surface_move (drag_x11->drag_surface,
+ x_root - drag_x11->hot_x,
+ y_root - drag_x11->hot_y);
+ gdk_surface_raise (drag_x11->drag_surface);
}
static gboolean
-gdk_x11_drag_context_drag_motion (GdkDragContext *context,
+gdk_x11_drag_drag_motion (GdkDrag *drag,
Window proxy_xid,
GdkDragProtocol protocol,
gint x_root,
GdkDragAction possible_actions,
guint32 time)
{
- GdkX11DragContext *context_x11 = GDK_X11_DRAG_CONTEXT (context);
+ GdkX11Drag *drag_x11 = GDK_X11_DRAG (drag);
- if (context_x11->drag_surface)
- move_drag_surface (context, x_root, y_root);
+ if (drag_x11->drag_surface)
+ move_drag_surface (drag, x_root, y_root);
- gdk_drag_context_set_actions (context, possible_actions, suggested_action);
+ gdk_drag_set_actions (drag, possible_actions, suggested_action);
- if (protocol == GDK_DRAG_PROTO_XDND && context_x11->version == 0)
+ if (protocol == GDK_DRAG_PROTO_XDND && drag_x11->version == 0)
{
/* This ugly hack is necessary since GTK+ doesn't know about
* the XDND protocol version, and in particular doesn't know
* that gdk_drag_find_window() has the side-effect
- * of setting context_x11->version, and therefore sometimes call
- * gdk_x11_drag_context_drag_motion() without a prior call to
+ * of setting drag_x11->version, and therefore sometimes call
+ * gdk_x11_drag_drag_motion() without a prior call to
* gdk_drag_find_window(). This happens, e.g.
* when GTK+ is proxying DND events to embedded windows.
*/
if (proxy_xid)
{
- GdkDisplay *display = gdk_drag_context_get_display (context);
+ GdkDisplay *display = gdk_drag_get_display (drag);
xdnd_check_dest (display,
proxy_xid,
- &context_x11->version);
+ &drag_x11->version);
}
}
/* When we have a Xdnd target, make sure our XdndActionList
* matches the current actions;
*/
- if (protocol == GDK_DRAG_PROTO_XDND && context_x11->xdnd_actions != gdk_drag_context_get_actions (context))
+ if (protocol == GDK_DRAG_PROTO_XDND && drag_x11->xdnd_actions != gdk_drag_get_actions (drag))
{
if (proxy_xid)
{
- GdkDisplay *display = gdk_drag_context_get_display (context);
+ GdkDisplay *display = gdk_drag_get_display (drag);
GdkDrop *drop = GDK_X11_DISPLAY (display)->current_drop;
if (drop && GDK_SURFACE_XID (gdk_drop_get_surface (drop)) == proxy_xid)
gdk_x11_drop_read_actions (drop);
else
- xdnd_set_actions (context_x11);
+ xdnd_set_actions (drag_x11);
}
}
- if (context_x11->proxy_xid != proxy_xid)
+ if (drag_x11->proxy_xid != proxy_xid)
{
/* Send a leave to the last destination */
- gdk_drag_do_leave (context_x11, time);
- context_x11->drag_status = GDK_DRAG_STATUS_DRAG;
+ gdk_drag_do_leave (drag_x11, time);
+ drag_x11->drag_status = GDK_DRAG_STATUS_DRAG;
/* Check if new destination accepts drags, and which protocol */
if (proxy_xid)
{
- context_x11->proxy_xid = proxy_xid;
- context_x11->drop_xid = context_x11->dest_xid;
- context_x11->protocol = protocol;
+ drag_x11->proxy_xid = proxy_xid;
+ drag_x11->drop_xid = drag_x11->dest_xid;
+ drag_x11->protocol = protocol;
switch (protocol)
{
case GDK_DRAG_PROTO_XDND:
- xdnd_send_enter (context_x11);
+ xdnd_send_enter (drag_x11);
break;
case GDK_DRAG_PROTO_ROOTWIN:
}
else
{
- context_x11->proxy_xid = None;
- context_x11->drop_xid = None;
- context->action = 0;
+ drag_x11->proxy_xid = None;
+ drag_x11->drop_xid = None;
+ drag->action = 0;
}
/* Push a status event, to let the client know that
* the drag changed
*/
- if (context->action != context_x11->current_action)
+ if (drag->action != drag_x11->current_action)
{
- context_x11->current_action = context->action;
- g_signal_emit_by_name (context, "action-changed", context->action);
+ drag_x11->current_action = drag->action;
+ g_signal_emit_by_name (drag, "action-changed", drag->action);
}
}
/* Send a drag-motion event */
- context_x11->last_x = x_root;
- context_x11->last_y = y_root;
+ drag_x11->last_x = x_root;
+ drag_x11->last_y = y_root;
- if (context_x11->proxy_xid)
+ if (drag_x11->proxy_xid)
{
- GdkDisplay *display = gdk_drag_context_get_display (context);
+ GdkDisplay *display = gdk_drag_get_display (drag);
GdkX11Screen *screen_x11 = GDK_X11_SCREEN(GDK_X11_DISPLAY (display)->screen);
- if (context_x11->drag_status == GDK_DRAG_STATUS_DRAG)
+ if (drag_x11->drag_status == GDK_DRAG_STATUS_DRAG)
{
- switch (context_x11->protocol)
+ switch (drag_x11->protocol)
{
case GDK_DRAG_PROTO_XDND:
- xdnd_send_motion (context_x11, x_root * screen_x11->surface_scale, y_root * screen_x11->surface_scale, suggested_action, time);
+ xdnd_send_motion (drag_x11, x_root * screen_x11->surface_scale, y_root * screen_x11->surface_scale, suggested_action, time);
break;
case GDK_DRAG_PROTO_ROOTWIN:
{
- GdkContentFormats *formats = gdk_drag_context_get_formats (context);
+ GdkContentFormats *formats = gdk_drag_get_formats (drag);
/* GTK+ traditionally has used application/x-rootwin-drop,
* but the XDND spec specifies x-rootwindow-drop.
*/
if (gdk_content_formats_contain_mime_type (formats, "application/x-rootwindow-drop") ||
gdk_content_formats_contain_mime_type (formats, "application/x-rootwin-drop"))
- context->action = gdk_drag_context_get_suggested_action (context);
+ drag->action = gdk_drag_get_suggested_action (drag);
else
- context->action = 0;
+ drag->action = 0;
- if (context->action != context_x11->current_action)
+ if (drag->action != drag_x11->current_action)
{
- context_x11->current_action = context->action;
- g_signal_emit_by_name (context, "action-changed", context->action);
+ drag_x11->current_action = drag->action;
+ g_signal_emit_by_name (drag, "action-changed", drag->action);
}
}
break;
case GDK_DRAG_PROTO_NONE:
- g_warning ("Invalid drag protocol %u in gdk_x11_drag_context_drag_motion()", context_x11->protocol);
+ g_warning ("Invalid drag protocol %u in gdk_x11_drag_drag_motion()", drag_x11->protocol);
break;
default:
break;
}
static void
-gdk_x11_drag_context_drag_abort (GdkDragContext *context,
+gdk_x11_drag_drag_abort (GdkDrag *drag,
guint32 time)
{
- gdk_drag_do_leave (GDK_X11_DRAG_CONTEXT (context), time);
+ gdk_drag_do_leave (GDK_X11_DRAG (drag), time);
}
static void
-gdk_x11_drag_context_drag_drop (GdkDragContext *context,
+gdk_x11_drag_drag_drop (GdkDrag *drag,
guint32 time)
{
- GdkX11DragContext *context_x11 = GDK_X11_DRAG_CONTEXT (context);
+ GdkX11Drag *drag_x11 = GDK_X11_DRAG (drag);
- if (context_x11->proxy_xid)
+ if (drag_x11->proxy_xid)
{
- switch (context_x11->protocol)
+ switch (drag_x11->protocol)
{
case GDK_DRAG_PROTO_XDND:
- xdnd_send_drop (context_x11, time);
+ xdnd_send_drop (drag_x11, time);
break;
case GDK_DRAG_PROTO_ROOTWIN:
g_warning ("GDK_DRAG_PROTO_NONE is not valid in gdk_drag_drop()");
break;
default:
- g_warning ("Drag protocol %u is not valid in gdk_drag_drop()", context_x11->protocol);
+ g_warning ("Drag protocol %u is not valid in gdk_drag_drop()", drag_x11->protocol);
break;
}
}
}
static GdkSurface *
-gdk_x11_drag_context_get_drag_surface (GdkDragContext *context)
+gdk_x11_drag_get_drag_surface (GdkDrag *drag)
{
- return GDK_X11_DRAG_CONTEXT (context)->drag_surface;
+ return GDK_X11_DRAG (drag)->drag_surface;
}
static void
-gdk_x11_drag_context_set_hotspot (GdkDragContext *context,
+gdk_x11_drag_set_hotspot (GdkDrag *drag,
gint hot_x,
gint hot_y)
{
- GdkX11DragContext *x11_context = GDK_X11_DRAG_CONTEXT (context);
+ GdkX11Drag *x11_drag = GDK_X11_DRAG (drag);
- x11_context->hot_x = hot_x;
- x11_context->hot_y = hot_y;
+ x11_drag->hot_x = hot_x;
+ x11_drag->hot_y = hot_y;
- if (x11_context->grab_seat)
+ if (x11_drag->grab_seat)
{
/* DnD is managed, update current position */
- move_drag_surface (context, x11_context->last_x, x11_context->last_y);
+ move_drag_surface (drag, x11_drag->last_x, x11_drag->last_y);
}
}
static void
-gdk_x11_drag_context_default_output_done (GObject *context,
+gdk_x11_drag_default_output_done (GObject *drag,
GAsyncResult *result,
gpointer user_data)
{
GError *error = NULL;
- if (!gdk_drag_context_write_finish (GDK_DRAG_CONTEXT (context), result, &error))
+ if (!gdk_drag_write_finish (GDK_DRAG (drag), result, &error))
{
- GDK_DISPLAY_NOTE (gdk_drag_context_get_display (GDK_DRAG_CONTEXT (context)), DND, g_printerr ("failed to write stream: %s\n", error->message));
+ GDK_DISPLAY_NOTE (gdk_drag_get_display (GDK_DRAG (drag)), DND, g_printerr ("failed to write stream: %s\n", error->message));
g_error_free (error);
}
}
static void
-gdk_x11_drag_context_default_output_handler (GOutputStream *stream,
+gdk_x11_drag_default_output_handler (GOutputStream *stream,
const char *mime_type,
gpointer user_data)
{
- gdk_drag_context_write_async (GDK_DRAG_CONTEXT (user_data),
+ gdk_drag_write_async (GDK_DRAG (user_data),
mime_type,
stream,
G_PRIORITY_DEFAULT,
NULL,
- gdk_x11_drag_context_default_output_done,
+ gdk_x11_drag_default_output_done,
NULL);
g_object_unref (stream);
}
static gboolean
-gdk_x11_drag_context_xevent (GdkDisplay *display,
+gdk_x11_drag_xevent (GdkDisplay *display,
const XEvent *xevent,
gpointer data)
{
- GdkDragContext *context = GDK_DRAG_CONTEXT (data);
- GdkX11DragContext *x11_context = GDK_X11_DRAG_CONTEXT (context);
+ GdkDrag *drag = GDK_DRAG (data);
+ GdkX11Drag *x11_drag = GDK_X11_DRAG (drag);
Window xwindow;
Atom xselection;
- xwindow = GDK_SURFACE_XID (x11_context->ipc_surface);
+ xwindow = GDK_SURFACE_XID (x11_drag->ipc_surface);
xselection = gdk_x11_get_xatom_by_name_for_display (display, "XdndSelection");
if (xevent->xany.window != xwindow)
if (xevent->xselectionclear.selection != xselection)
return FALSE;
- if (xevent->xselectionclear.time < x11_context->timestamp)
+ if (xevent->xselectionclear.time < x11_drag->timestamp)
{
GDK_DISPLAY_NOTE (display, CLIPBOARD, g_printerr ("ignoring SelectionClear with too old timestamp (%lu vs %lu)\n",
- xevent->xselectionclear.time, x11_context->timestamp));
+ xevent->xselectionclear.time, x11_drag->timestamp));
return FALSE;
}
GDK_DISPLAY_NOTE (display, CLIPBOARD, g_printerr ("got SelectionClear, aborting DND\n"));
- gdk_drag_context_cancel (context, GDK_DRAG_CANCEL_ERROR);
+ gdk_drag_cancel (drag, GDK_DRAG_CANCEL_ERROR);
return TRUE;
case SelectionRequest:
target, property));
gdk_x11_selection_output_streams_create (display,
- gdk_drag_context_get_formats (context),
+ gdk_drag_get_formats (drag),
xevent->xselectionrequest.requestor,
xevent->xselectionrequest.selection,
xevent->xselectionrequest.target,
xevent->xselectionrequest.property ? xevent->xselectionrequest.property
: xevent->xselectionrequest.target,
xevent->xselectionrequest.time,
- gdk_x11_drag_context_default_output_handler,
- context);
+ gdk_x11_drag_default_output_handler,
+ drag);
return TRUE;
}
case ClientMessage:
if (xevent->xclient.message_type == gdk_x11_get_xatom_by_name_for_display (display, "XdndStatus"))
- gdk_x11_drag_context_handle_status (display, xevent);
+ gdk_x11_drag_handle_status (display, xevent);
else if (xevent->xclient.message_type == gdk_x11_get_xatom_by_name_for_display (display, "XdndFinished"))
- gdk_x11_drag_context_handle_finished (display, xevent);
+ gdk_x11_drag_handle_finished (display, xevent);
else
return FALSE;
return TRUE;
typedef struct _GdkDragAnim GdkDragAnim;
struct _GdkDragAnim {
- GdkX11DragContext *context;
+ GdkX11Drag *drag;
GdkFrameClock *frame_clock;
gint64 start_time;
};
static void
gdk_drag_anim_destroy (GdkDragAnim *anim)
{
- g_object_unref (anim->context);
+ g_object_unref (anim->drag);
g_slice_free (GdkDragAnim, anim);
}
gdk_drag_anim_timeout (gpointer data)
{
GdkDragAnim *anim = data;
- GdkX11DragContext *context = anim->context;
+ GdkX11Drag *drag = anim->drag;
GdkFrameClock *frame_clock = anim->frame_clock;
gint64 current_time;
double f;
t = ease_out_cubic (f);
- gdk_surface_show (context->drag_surface);
- gdk_surface_move (context->drag_surface,
- context->last_x + (context->start_x - context->last_x) * t,
- context->last_y + (context->start_y - context->last_y) * t);
- gdk_surface_set_opacity (context->drag_surface, 1.0 - f);
+ gdk_surface_show (drag->drag_surface);
+ gdk_surface_move (drag->drag_surface,
+ drag->last_x + (drag->start_x - drag->last_x) * t,
+ drag->last_y + (drag->start_y - drag->last_y) * t);
+ gdk_surface_set_opacity (drag->drag_surface, 1.0 - f);
return G_SOURCE_CONTINUE;
}
static void
-gdk_x11_drag_context_release_selection (GdkDragContext *context)
+gdk_x11_drag_release_selection (GdkDrag *drag)
{
- GdkX11DragContext *x11_context = GDK_X11_DRAG_CONTEXT (context);
+ GdkX11Drag *x11_drag = GDK_X11_DRAG (drag);
GdkDisplay *display;
Display *xdisplay;
Window xwindow;
Atom xselection;
- display = gdk_drag_context_get_display (context);
+ display = gdk_drag_get_display (drag);
xdisplay = GDK_DISPLAY_XDISPLAY (display);
xselection = gdk_x11_get_xatom_by_name_for_display (display, "XdndSelection");
- xwindow = GDK_SURFACE_XID (x11_context->ipc_surface);
+ xwindow = GDK_SURFACE_XID (x11_drag->ipc_surface);
if (XGetSelectionOwner (xdisplay, xselection) == xwindow)
XSetSelectionOwner (xdisplay, xselection, None, CurrentTime);
}
static void
-gdk_x11_drag_context_drop_done (GdkDragContext *context,
+gdk_x11_drag_drop_done (GdkDrag *drag,
gboolean success)
{
- GdkX11DragContext *x11_context = GDK_X11_DRAG_CONTEXT (context);
+ GdkX11Drag *x11_drag = GDK_X11_DRAG (drag);
GdkDragAnim *anim;
/*
cairo_surface_t *win_surface;
*/
guint id;
- gdk_x11_drag_context_release_selection (context);
+ gdk_x11_drag_release_selection (drag);
- g_signal_handlers_disconnect_by_func (gdk_drag_context_get_display (context),
- gdk_x11_drag_context_xevent,
- context);
+ g_signal_handlers_disconnect_by_func (gdk_drag_get_display (drag),
+ gdk_x11_drag_xevent,
+ drag);
if (success)
{
- gdk_surface_hide (x11_context->drag_surface);
+ gdk_surface_hide (x11_drag->drag_surface);
return;
}
/*
- win_surface = _gdk_surface_ref_cairo_surface (x11_context->drag_surface);
- surface = gdk_surface_create_similar_surface (x11_context->drag_surface,
+ win_surface = _gdk_surface_ref_cairo_surface (x11_drag->drag_surface);
+ surface = gdk_surface_create_similar_surface (x11_drag->drag_surface,
cairo_surface_get_content (win_surface),
- gdk_surface_get_width (x11_context->drag_surface),
- gdk_surface_get_height (x11_context->drag_surface));
+ gdk_surface_get_width (x11_drag->drag_surface),
+ gdk_surface_get_height (x11_drag->drag_surface));
cr = cairo_create (surface);
cairo_set_source_surface (cr, win_surface, 0, 0);
cairo_paint (cr);
pattern = cairo_pattern_create_for_surface (surface);
- gdk_surface_set_background_pattern (x11_context->drag_surface, pattern);
+ gdk_surface_set_background_pattern (x11_drag->drag_surface, pattern);
cairo_pattern_destroy (pattern);
cairo_surface_destroy (surface);
*/
anim = g_slice_new0 (GdkDragAnim);
- anim->context = g_object_ref (x11_context);
- anim->frame_clock = gdk_surface_get_frame_clock (x11_context->drag_surface);
+ anim->drag = g_object_ref (x11_drag);
+ anim->frame_clock = gdk_surface_get_frame_clock (x11_drag->drag_surface);
anim->start_time = gdk_frame_clock_get_frame_time (anim->frame_clock);
id = g_timeout_add_full (G_PRIORITY_DEFAULT, 17,
}
static gboolean
-drag_context_grab (GdkDragContext *context)
+drag_grab (GdkDrag *drag)
{
- GdkX11DragContext *x11_context = GDK_X11_DRAG_CONTEXT (context);
- GdkDevice *device = gdk_drag_context_get_device (context);
+ GdkX11Drag *x11_drag = GDK_X11_DRAG (drag);
+ GdkDevice *device = gdk_drag_get_device (drag);
GdkSeatCapabilities capabilities;
GdkDisplay *display;
Window root;
gint keycode, i;
GdkCursor *cursor;
- if (!x11_context->ipc_surface)
+ if (!x11_drag->ipc_surface)
return FALSE;
- display = gdk_drag_context_get_display (context);
+ display = gdk_drag_get_display (drag);
root = GDK_DISPLAY_XROOTWIN (display);
- seat = gdk_device_get_seat (gdk_drag_context_get_device (context));
+ seat = gdk_device_get_seat (gdk_drag_get_device (drag));
#ifdef XINPUT_2
if (GDK_IS_X11_DEVICE_XI2 (device))
#endif
capabilities = GDK_SEAT_CAPABILITY_ALL;
- cursor = gdk_drag_get_cursor (context, x11_context->current_action);
- g_set_object (&x11_context->cursor, cursor);
+ cursor = gdk_drag_get_cursor (drag, x11_drag->current_action);
+ g_set_object (&x11_drag->cursor, cursor);
- if (gdk_seat_grab (seat, x11_context->ipc_surface,
+ if (gdk_seat_grab (seat, x11_drag->ipc_surface,
capabilities, FALSE,
- x11_context->cursor, NULL, NULL, NULL) != GDK_GRAB_SUCCESS)
+ x11_drag->cursor, NULL, NULL, NULL) != GDK_GRAB_SUCCESS)
return FALSE;
- g_set_object (&x11_context->grab_seat, seat);
+ g_set_object (&x11_drag->grab_seat, seat);
gdk_x11_display_error_trap_push (display);
}
static void
-drag_context_ungrab (GdkDragContext *context)
+drag_ungrab (GdkDrag *drag)
{
- GdkX11DragContext *x11_context = GDK_X11_DRAG_CONTEXT (context);
+ GdkX11Drag *x11_drag = GDK_X11_DRAG (drag);
GdkDisplay *display;
GdkDevice *keyboard;
Window root;
gint keycode, i;
- if (!x11_context->grab_seat)
+ if (!x11_drag->grab_seat)
return;
- gdk_seat_ungrab (x11_context->grab_seat);
+ gdk_seat_ungrab (x11_drag->grab_seat);
- display = gdk_drag_context_get_display (context);
- keyboard = gdk_seat_get_keyboard (x11_context->grab_seat);
+ display = gdk_drag_get_display (drag);
+ keyboard = gdk_seat_get_keyboard (x11_drag->grab_seat);
root = GDK_DISPLAY_XROOTWIN (display);
- g_clear_object (&x11_context->grab_seat);
+ g_clear_object (&x11_drag->grab_seat);
for (i = 0; i < G_N_ELEMENTS (grab_keys); ++i)
{
}
}
-GdkDragContext *
-_gdk_x11_surface_drag_begin (GdkSurface *surface,
- GdkDevice *device,
- GdkContentProvider *content,
- GdkDragAction actions,
- gint dx,
- gint dy)
+GdkDrag *
+_gdk_x11_surface_drag_begin (GdkSurface *surface,
+ GdkDevice *device,
+ GdkContentProvider *content,
+ GdkDragAction actions,
+ gint dx,
+ gint dy)
{
- GdkX11DragContext *x11_context;
- GdkDragContext *context;
+ GdkX11Drag *x11_drag;
+ GdkDrag *drag;
GdkDisplay *display;
int x_root, y_root;
Atom xselection;
display = gdk_surface_get_display (surface);
- context = (GdkDragContext *) g_object_new (GDK_TYPE_X11_DRAG_CONTEXT,
+ drag = (GdkDrag *) g_object_new (GDK_TYPE_X11_DRAG,
"device", device,
"content", content,
NULL);
- x11_context = GDK_X11_DRAG_CONTEXT (context);
+ x11_drag = GDK_X11_DRAG (drag);
- g_signal_connect (display, "xevent", G_CALLBACK (gdk_x11_drag_context_xevent), context);
+ g_signal_connect (display, "xevent", G_CALLBACK (gdk_x11_drag_xevent), drag);
- precache_target_list (context);
+ precache_target_list (drag);
gdk_device_get_position (device, &x_root, &y_root);
x_root += dx;
y_root += dy;
- x11_context->start_x = x_root;
- x11_context->start_y = y_root;
- x11_context->last_x = x_root;
- x11_context->last_y = y_root;
+ x11_drag->start_x = x_root;
+ x11_drag->start_y = y_root;
+ x11_drag->last_x = x_root;
+ x11_drag->last_y = y_root;
- x11_context->protocol = GDK_DRAG_PROTO_XDND;
- x11_context->actions = actions;
- x11_context->ipc_surface = gdk_surface_new_popup (display, &(GdkRectangle) { -99, -99, 1, 1 });
+ x11_drag->protocol = GDK_DRAG_PROTO_XDND;
+ x11_drag->actions = actions;
+ x11_drag->ipc_surface = gdk_surface_new_popup (display, &(GdkRectangle) { -99, -99, 1, 1 });
if (gdk_surface_get_group (surface))
- gdk_surface_set_group (x11_context->ipc_surface, surface);
- gdk_surface_show (x11_context->ipc_surface);
+ gdk_surface_set_group (x11_drag->ipc_surface, surface);
+ gdk_surface_show (x11_drag->ipc_surface);
- context->source_surface = x11_context->ipc_surface;
- g_object_ref (context->source_surface);
+ drag->source_surface = x11_drag->ipc_surface;
+ g_object_ref (drag->source_surface);
- x11_context->drag_surface = create_drag_surface (display);
+ x11_drag->drag_surface = create_drag_surface (display);
- if (!drag_context_grab (context))
+ if (!drag_grab (drag))
{
- g_object_unref (context);
+ g_object_unref (drag);
return NULL;
}
- move_drag_surface (context, x_root, y_root);
+ move_drag_surface (drag, x_root, y_root);
- x11_context->timestamp = gdk_display_get_last_seen_time (display);
+ x11_drag->timestamp = gdk_display_get_last_seen_time (display);
xselection = gdk_x11_get_xatom_by_name_for_display (display, "XdndSelection");
XSetSelectionOwner (GDK_DISPLAY_XDISPLAY (display),
xselection,
- GDK_SURFACE_XID (x11_context->ipc_surface),
- x11_context->timestamp);
- if (XGetSelectionOwner (GDK_DISPLAY_XDISPLAY (display), xselection) != GDK_SURFACE_XID (x11_context->ipc_surface))
+ GDK_SURFACE_XID (x11_drag->ipc_surface),
+ x11_drag->timestamp);
+ if (XGetSelectionOwner (GDK_DISPLAY_XDISPLAY (display), xselection) != GDK_SURFACE_XID (x11_drag->ipc_surface))
{
GDK_DISPLAY_NOTE (display, DND, g_printerr ("failed XSetSelectionOwner() on \"XdndSelection\", aborting DND\n"));
- g_object_unref (context);
+ g_object_unref (drag);
return NULL;
}
- return context;
+ return drag;
}
static void
-gdk_x11_drag_context_set_cursor (GdkDragContext *context,
- GdkCursor *cursor)
+gdk_x11_drag_set_cursor (GdkDrag *drag,
+ GdkCursor *cursor)
{
- GdkX11DragContext *x11_context = GDK_X11_DRAG_CONTEXT (context);
+ GdkX11Drag *x11_drag = GDK_X11_DRAG (drag);
- if (!g_set_object (&x11_context->cursor, cursor))
+ if (!g_set_object (&x11_drag->cursor, cursor))
return;
- if (x11_context->grab_seat)
+ if (x11_drag->grab_seat)
{
G_GNUC_BEGIN_IGNORE_DEPRECATIONS;
- gdk_device_grab (gdk_seat_get_pointer (x11_context->grab_seat),
- x11_context->ipc_surface,
+ gdk_device_grab (gdk_seat_get_pointer (x11_drag->grab_seat),
+ x11_drag->ipc_surface,
GDK_OWNERSHIP_APPLICATION, FALSE,
GDK_POINTER_MOTION_MASK | GDK_BUTTON_RELEASE_MASK,
cursor, GDK_CURRENT_TIME);
}
static void
-gdk_x11_drag_context_cancel (GdkDragContext *context,
- GdkDragCancelReason reason)
+gdk_x11_drag_cancel (GdkDrag *drag,
+ GdkDragCancelReason reason)
{
- drag_context_ungrab (context);
- gdk_drag_drop_done (context, FALSE);
+ drag_ungrab (drag);
+ gdk_drag_drop_done (drag, FALSE);
}
static void
-gdk_x11_drag_context_drop_performed (GdkDragContext *context,
- guint32 time_)
+gdk_x11_drag_drop_performed (GdkDrag *drag,
+ guint32 time_)
{
- gdk_drag_drop (context, time_);
- drag_context_ungrab (context);
+ gdk_drag_drop (drag, time_);
+ drag_ungrab (drag);
}
#define BIG_STEP 20
}
static void
-gdk_drag_update (GdkDragContext *context,
+gdk_drag_update (GdkDrag *drag,
gdouble x_root,
gdouble y_root,
GdkModifierType mods,
guint32 evtime)
{
- GdkX11DragContext *x11_context = GDK_X11_DRAG_CONTEXT (context);
+ GdkX11Drag *x11_drag = GDK_X11_DRAG (drag);
GdkDragAction action, possible_actions;
GdkDragProtocol protocol;
Window proxy;
- gdk_drag_get_current_actions (mods, GDK_BUTTON_PRIMARY, x11_context->actions,
+ gdk_drag_get_current_actions (mods, GDK_BUTTON_PRIMARY, x11_drag->actions,
&action, &possible_actions);
- proxy = gdk_x11_drag_context_find_surface (context,
- x11_context->drag_surface,
+ proxy = gdk_x11_drag_find_surface (drag,
+ x11_drag->drag_surface,
x_root, y_root, &protocol);
- gdk_x11_drag_context_drag_motion (context, proxy, protocol, x_root, y_root,
+ gdk_x11_drag_drag_motion (drag, proxy, protocol, x_root, y_root,
action, possible_actions, evtime);
}
static gboolean
-gdk_dnd_handle_motion_event (GdkDragContext *context,
+gdk_dnd_handle_motion_event (GdkDrag *drag,
const GdkEventMotion *event)
{
GdkModifierType state;
if (!gdk_event_get_state ((GdkEvent *) event, &state))
return FALSE;
- gdk_drag_update (context, event->x_root, event->y_root, state,
+ gdk_drag_update (drag, event->x_root, event->y_root, state,
gdk_event_get_time ((GdkEvent *) event));
return TRUE;
}
static gboolean
-gdk_dnd_handle_key_event (GdkDragContext *context,
+gdk_dnd_handle_key_event (GdkDrag *drag,
const GdkEventKey *event)
{
- GdkX11DragContext *x11_context = GDK_X11_DRAG_CONTEXT (context);
+ GdkX11Drag *x11_drag = GDK_X11_DRAG (drag);
GdkModifierType state;
GdkDevice *pointer;
gint dx, dy;
switch (event->keyval)
{
case GDK_KEY_Escape:
- gdk_drag_context_cancel (context, GDK_DRAG_CANCEL_USER_CANCELLED);
+ gdk_drag_cancel (drag, GDK_DRAG_CANCEL_USER_CANCELLED);
return TRUE;
case GDK_KEY_space:
case GDK_KEY_ISO_Enter:
case GDK_KEY_KP_Enter:
case GDK_KEY_KP_Space:
- if ((gdk_drag_context_get_selected_action (context) != 0) &&
- (x11_context->proxy_xid != None))
+ if ((gdk_drag_get_selected_action (drag) != 0) &&
+ (x11_drag->proxy_xid != None))
{
- g_signal_emit_by_name (context, "drop-performed");
+ g_signal_emit_by_name (drag, "drop-performed");
}
else
- gdk_drag_context_cancel (context, GDK_DRAG_CANCEL_NO_TARGET);
+ gdk_drag_cancel (drag, GDK_DRAG_CANCEL_NO_TARGET);
return TRUE;
if (dx != 0 || dy != 0)
{
- x11_context->last_x += dx;
- x11_context->last_y += dy;
- gdk_device_warp (pointer, x11_context->last_x, x11_context->last_y);
+ x11_drag->last_x += dx;
+ x11_drag->last_y += dy;
+ gdk_device_warp (pointer, x11_drag->last_x, x11_drag->last_y);
}
- gdk_drag_update (context, x11_context->last_x, x11_context->last_y, state,
+ gdk_drag_update (drag, x11_drag->last_x, x11_drag->last_y, state,
gdk_event_get_time ((GdkEvent *) event));
return TRUE;
}
static gboolean
-gdk_dnd_handle_grab_broken_event (GdkDragContext *context,
+gdk_dnd_handle_grab_broken_event (GdkDrag *drag,
const GdkEventGrabBroken *event)
{
- GdkX11DragContext *x11_context = GDK_X11_DRAG_CONTEXT (context);
+ GdkX11Drag *x11_drag = GDK_X11_DRAG (drag);
/* Don't cancel if we break the implicit grab from the initial button_press.
* Also, don't cancel if we re-grab on the widget or on our IPC window, for
* example, when changing the drag cursor.
*/
if (event->implicit ||
- event->grab_surface == x11_context->drag_surface ||
- event->grab_surface == x11_context->ipc_surface)
+ event->grab_surface == x11_drag->drag_surface ||
+ event->grab_surface == x11_drag->ipc_surface)
return FALSE;
if (gdk_event_get_device ((GdkEvent *) event) !=
- gdk_drag_context_get_device (context))
+ gdk_drag_get_device (drag))
return FALSE;
- gdk_drag_context_cancel (context, GDK_DRAG_CANCEL_ERROR);
+ gdk_drag_cancel (drag, GDK_DRAG_CANCEL_ERROR);
return TRUE;
}
static gboolean
-gdk_dnd_handle_button_event (GdkDragContext *context,
+gdk_dnd_handle_button_event (GdkDrag *drag,
const GdkEventButton *event)
{
- GdkX11DragContext *x11_context = GDK_X11_DRAG_CONTEXT (context);
+ GdkX11Drag *x11_drag = GDK_X11_DRAG (drag);
#if 0
/* FIXME: Check the button matches */
- if (event->button != x11_context->button)
+ if (event->button != x11_drag->button)
return FALSE;
#endif
- if ((gdk_drag_context_get_selected_action (context) != 0) &&
- (x11_context->proxy_xid != None))
+ if ((gdk_drag_get_selected_action (drag) != 0) &&
+ (x11_drag->proxy_xid != None))
{
- g_signal_emit_by_name (context, "drop-performed");
+ g_signal_emit_by_name (drag, "drop-performed");
}
else
- gdk_drag_context_cancel (context, GDK_DRAG_CANCEL_NO_TARGET);
+ gdk_drag_cancel (drag, GDK_DRAG_CANCEL_NO_TARGET);
return TRUE;
}
gboolean
-gdk_x11_drag_context_handle_event (GdkDragContext *context,
- const GdkEvent *event)
+gdk_x11_drag_handle_event (GdkDrag *drag,
+ const GdkEvent *event)
{
- GdkX11DragContext *x11_context = GDK_X11_DRAG_CONTEXT (context);
+ GdkX11Drag *x11_drag = GDK_X11_DRAG (drag);
- if (!x11_context->grab_seat)
+ if (!x11_drag->grab_seat)
return FALSE;
switch ((guint) event->any.type)
{
case GDK_MOTION_NOTIFY:
- return gdk_dnd_handle_motion_event (context, &event->motion);
+ return gdk_dnd_handle_motion_event (drag, &event->motion);
case GDK_BUTTON_RELEASE:
- return gdk_dnd_handle_button_event (context, &event->button);
+ return gdk_dnd_handle_button_event (drag, &event->button);
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
- return gdk_dnd_handle_key_event (context, &event->key);
+ return gdk_dnd_handle_key_event (drag, &event->key);
case GDK_GRAB_BROKEN:
- return gdk_dnd_handle_grab_broken_event (context, &event->grab_broken);
+ return gdk_dnd_handle_grab_broken_event (drag, &event->grab_broken);
default:
break;
}
}
void
-gdk_x11_drag_context_action_changed (GdkDragContext *context,
- GdkDragAction action)
-{
+gdk_x11_drag_action_changed (GdkDrag *drag,
+ GdkDragAction action)
+{
GdkCursor *cursor;
- cursor = gdk_drag_get_cursor (context, action);
- gdk_drag_context_set_cursor (context, cursor);
+ cursor = gdk_drag_get_cursor (drag, action);
+ gdk_drag_set_cursor (drag, cursor);
}
{
GdkX11Drop *drop_x11 = GDK_X11_DROP (drop);
GdkDisplay *display = gdk_drop_get_display (drop);
- GdkDragContext *drag;
+ GdkDrag *drag;
GdkDragAction actions = GDK_ACTION_COPY | GDK_ACTION_MOVE | GDK_ACTION_LINK | GDK_ACTION_ASK;
Atom type;
int format;
}
else
{
- actions = gdk_drag_context_get_actions (drag);
+ actions = gdk_drag_get_actions (drag);
drop_x11->xdnd_have_actions = TRUE;
}
GdkX11Display *display_x11;
GdkDrop *drop;
GdkX11Drop *drop_x11;
- GdkDragContext *drag;
+ GdkDrag *drag;
GdkSeat *seat;
gint i;
Atom type;
print_target_list (content_formats);
#endif /* G_ENABLE_DEBUG */
- drag = gdk_x11_drag_context_find (display, source_window, GDK_SURFACE_XID (surface));
+ drag = gdk_x11_drag_find (display, source_window, GDK_SURFACE_XID (surface));
drop_x11 = g_object_new (GDK_TYPE_X11_DROP,
"device", gdk_seat_get_pointer (seat),
if (gdk_drop_get_drag (drop))
{
- gdk_x11_drag_context_handle_status (display, &xev);
+ gdk_x11_drag_handle_status (display, &xev);
}
else
{
if (gdk_drop_get_drag (drop))
{
- gdk_x11_drag_context_handle_status (display, &xev);
+ gdk_x11_drag_handle_status (display, &xev);
}
else
{
}
static void
-gdk_x11_drop_init (GdkX11Drop *context)
+gdk_x11_drop_init (GdkX11Drop *drag)
{
}
const gchar *format,
...) G_GNUC_PRINTF (2, 3);
-GdkDragContext *gdk_x11_drag_context_find (GdkDisplay *display,
- Window source_xid,
- Window dest_xid);
-void gdk_x11_drag_context_handle_status (GdkDisplay *display,
- const XEvent *xevent);
-void gdk_x11_drag_context_handle_finished (GdkDisplay *display,
- const XEvent *xevent);
-void gdk_x11_drop_read_actions (GdkDrop *drop);
-gboolean gdk_x11_drop_filter (GdkSurface *surface,
- const XEvent *xevent);
+GdkDrag *gdk_x11_drag_find (GdkDisplay *display,
+ Window source_xid,
+ Window dest_xid);
+void gdk_x11_drag_handle_status (GdkDisplay *display,
+ const XEvent *xevent);
+void gdk_x11_drag_handle_finished (GdkDisplay *display,
+ const XEvent *xevent);
+void gdk_x11_drop_read_actions (GdkDrop *drop);
+gboolean gdk_x11_drop_filter (GdkSurface *surface,
+ const XEvent *xevent);
typedef struct _GdkSurfaceCache GdkSurfaceCache;
void _gdk_x11_surface_register_dnd (GdkSurface *window);
-GdkDragContext * _gdk_x11_surface_drag_begin (GdkSurface *window,
+GdkDrag * _gdk_x11_surface_drag_begin (GdkSurface *window,
GdkDevice *device,
GdkContentProvider *content,
GdkDragAction actions,
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkX11DeviceManagerXI2, g_object_unref)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkX11DeviceXI2, g_object_unref)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkX11Display, g_object_unref)
-G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkX11DragContext, g_object_unref)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkX11Drag, g_object_unref)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkX11GLContext, g_object_unref)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkX11Keymap, g_object_unref)
G_DEFINE_AUTOPTR_CLEANUP_FUNC(GdkX11Screen, g_object_unref)
G_BEGIN_DECLS
-#define GDK_TYPE_X11_DRAG_CONTEXT (gdk_x11_drag_context_get_type ())
-#define GDK_X11_DRAG_CONTEXT(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_DRAG_CONTEXT, GdkX11DragContext))
-#define GDK_X11_DRAG_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_DRAG_CONTEXT, GdkX11DragContextClass))
-#define GDK_IS_X11_DRAG_CONTEXT(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_DRAG_CONTEXT))
-#define GDK_IS_X11_DRAG_CONTEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_DRAG_CONTEXT))
-#define GDK_X11_DRAG_CONTEXT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_DRAG_CONTEXT, GdkX11DragContextClass))
+#define GDK_TYPE_X11_DRAG (gdk_x11_drag_get_type ())
+#define GDK_X11_DRAG(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_X11_DRAG, GdkX11Drag))
+#define GDK_X11_DRAG_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_X11_DRAG, GdkX11DragClass))
+#define GDK_IS_X11_DRAG(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_X11_DRAG))
+#define GDK_IS_X11_DRAG_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_X11_DRAG))
+#define GDK_X11_DRAG_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_X11_DRAG, GdkX11DragClass))
#ifdef GDK_COMPILATION
-typedef struct _GdkX11DragContext GdkX11DragContext;
+typedef struct _GdkX11Drag GdkX11Drag;
#else
-typedef GdkDragContext GdkX11DragContext;
+typedef GdkDrag GdkX11Drag;
#endif
-typedef struct _GdkX11DragContextClass GdkX11DragContextClass;
+typedef struct _GdkX11DragClass GdkX11DragClass;
GDK_AVAILABLE_IN_ALL
-GType gdk_x11_drag_context_get_type (void);
+GType gdk_x11_drag_get_type (void);
G_END_DECLS
-#endif /* __GDK_X11_DRAG_CONTEXT_H__ */
+#endif /* __GDK_X11_DRAG_H__ */
GtkTooltip *tooltip);
static void gtk_calendar_drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data);
static void gtk_calendar_drag_data_received (GtkWidget *widget,
GdkDrop *drop,
GtkWidget *widget = data;
GtkCalendarPrivate *priv = GTK_CALENDAR (widget)->priv;
gdouble start_x, start_y;
- GdkDragContext *context;
+ GdkDrag *drag;
GdkContentFormats *targets;
if (!priv->in_drag)
targets = gdk_content_formats_new (NULL, 0);
targets = gtk_content_formats_add_text_targets (targets);
- context = gtk_drag_begin_with_coordinates (widget,
- gtk_gesture_get_device (GTK_GESTURE (gesture)),
- targets, GDK_ACTION_COPY,
- start_x, start_y);
+ drag = gtk_drag_begin_with_coordinates (widget,
+ gtk_gesture_get_device (GTK_GESTURE (gesture)),
+ targets, GDK_ACTION_COPY,
+ start_x, start_y);
priv->in_drag = 0;
gdk_content_formats_unref (targets);
- gtk_drag_set_icon_default (context);
+ gtk_drag_set_icon_default (drag);
}
static void
static void
gtk_calendar_drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data)
{
GtkCalendar *calendar = GTK_CALENDAR (widget);
/* source side drag signals */
static void gtk_color_button_drag_begin (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
gpointer data);
static void gtk_color_button_drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data,
GtkColorButton *button);
}
static void
-set_color_icon (GdkDragContext *context,
+set_color_icon (GdkDrag *drag,
const GdkRGBA *rgba)
{
GtkSnapshot *snapshot;
&GRAPHENE_RECT_INIT(0, 0, 48, 32));
paintable = gtk_snapshot_free_to_paintable (snapshot, NULL);
- gtk_drag_set_icon_paintable (context, paintable, 0, 0);
+ gtk_drag_set_icon_paintable (drag, paintable, 0, 0);
g_object_unref (paintable);
}
static void
gtk_color_button_drag_begin (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
gpointer data)
{
GtkColorButton *button = data;
GtkColorButtonPrivate *priv = gtk_color_button_get_instance_private (button);
- set_color_icon (context, &priv->rgba);
+ set_color_icon (drag, &priv->rgba);
}
static void
gtk_color_button_drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data,
GtkColorButton *button)
{
static void
-drag_set_color_icon (GdkDragContext *context,
+drag_set_color_icon (GdkDrag *drag,
const GdkRGBA *color)
{
GtkSnapshot *snapshot;
&GRAPHENE_RECT_INIT(0, 0, 48, 32));
paintable = gtk_snapshot_free_to_paintable (snapshot, NULL);
- gtk_drag_set_icon_paintable (context, paintable, 4, 4);
+ gtk_drag_set_icon_paintable (drag, paintable, 4, 4);
g_object_unref (paintable);
}
static void
swatch_drag_begin (GtkWidget *widget,
- GdkDragContext *context)
+ GdkDrag *drag)
{
GtkColorSwatch *swatch = GTK_COLOR_SWATCH (widget);
GdkRGBA color;
gtk_color_swatch_get_rgba (swatch, &color);
- drag_set_color_icon (context, &color);
+ drag_set_color_icon (drag, &color);
}
static void
swatch_drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data)
{
GtkColorSwatch *swatch = GTK_COLOR_SWATCH (widget);
{
GtkWidget *widget;
GdkContentFormats *target_list; /* Targets for drag data */
- GdkDragContext *context; /* drag context */
+ GdkDrag *drag; /* drag context */
GtkWidget *icon_window; /* Window for drag */
GtkWidget *icon_widget; /* Widget for drag */
static GtkDragDestInfo * gtk_drag_get_dest_info (GdkDrop *drop,
gboolean create);
-static GtkDragSourceInfo *gtk_drag_get_source_info (GdkDragContext *context,
+static GtkDragSourceInfo *gtk_drag_get_source_info (GdkDrag *drag,
gboolean create);
-static void gtk_drag_clear_source_info (GdkDragContext *context);
+static void gtk_drag_clear_source_info (GdkDrag *drag);
static void gtk_drag_drop (GtkDragSourceInfo *info);
static void gtk_drag_drop_finished (GtkDragSourceInfo *info,
static void gtk_drag_remove_icon (GtkDragSourceInfo *info);
static void gtk_drag_source_info_destroy (GtkDragSourceInfo *info);
-static void gtk_drag_context_drop_performed_cb (GdkDragContext *context,
- GtkDragSourceInfo *info);
-static void gtk_drag_context_cancel_cb (GdkDragContext *context,
- GdkDragCancelReason reason,
- GtkDragSourceInfo *info);
-static void gtk_drag_context_dnd_finished_cb (GdkDragContext *context,
- GtkDragSourceInfo *info);
+static void gtk_drag_drop_performed_cb (GdkDrag *drag,
+ GtkDragSourceInfo *info);
+static void gtk_drag_cancel_cb (GdkDrag *drag,
+ GdkDragCancelReason reason,
+ GtkDragSourceInfo *info);
+static void gtk_drag_dnd_finished_cb (GdkDrag *drag,
+ GtkDragSourceInfo *info);
static gboolean gtk_drag_abort_timeout (gpointer data);
-static void set_icon_helper (GdkDragContext *context,
- GtkImageDefinition*def,
- gint hot_x,
- gint hot_y);
+static void set_icon_helper (GdkDrag *drag,
+ GtkImageDefinition *def,
+ gint hot_x,
+ gint hot_y);
/********************
/**
* gtk_drag_get_source_widget:
- * @context: a (destination side) drag context
+ * @drag: a drag context
*
* Determines the source widget for a drag.
*
* Otherwise, %NULL.
*/
GtkWidget *
-gtk_drag_get_source_widget (GdkDragContext *context)
+gtk_drag_get_source_widget (GdkDrag *drag)
{
GtkDragSourceInfo *info;
- g_return_val_if_fail (GDK_IS_DRAG_CONTEXT (context), NULL);
+ g_return_val_if_fail (GDK_IS_DRAG (drag), NULL);
- info = gtk_drag_get_source_info (context, FALSE);
+ info = gtk_drag_get_source_info (drag, FALSE);
if (info == NULL)
return NULL;
static GQuark dest_info_quark = 0;
static GtkDragSourceInfo *
-gtk_drag_get_source_info (GdkDragContext *context,
- gboolean create)
+gtk_drag_get_source_info (GdkDrag *drag,
+ gboolean create)
{
GtkDragSourceInfo *info;
if (!dest_info_quark)
dest_info_quark = g_quark_from_static_string ("gtk-source-info");
- info = g_object_get_qdata (G_OBJECT (context), dest_info_quark);
+ info = g_object_get_qdata (G_OBJECT (drag), dest_info_quark);
if (!info && create)
{
info = g_new0 (GtkDragSourceInfo, 1);
- info->context = context;
- g_object_set_qdata (G_OBJECT (context), dest_info_quark, info);
+ info->drag = drag;
+ g_object_set_qdata (G_OBJECT (drag), dest_info_quark, info);
}
return info;
}
static void
-gtk_drag_clear_source_info (GdkDragContext *context)
+gtk_drag_clear_source_info (GdkDrag *drag)
{
- g_object_set_qdata (G_OBJECT (context), dest_info_quark, NULL);
+ g_object_set_qdata (G_OBJECT (drag), dest_info_quark, NULL);
}
/*
GdkContentProvider parent;
GtkWidget *widget;
- GdkDragContext *context;
+ GdkDrag *drag;
GdkContentFormats *formats;
guint32 time;
};
sdata.display = gtk_widget_get_display (content->widget);
g_signal_emit_by_name (content->widget, "drag-data-get",
- content->context,
+ content->drag,
&sdata);
if (sdata.length == -1)
/* Like gtk_drag_begin(), but also takes a GtkImageDefinition
* so that we can set the icon from the source site information
*/
-GdkDragContext *
+GdkDrag *
gtk_drag_begin_internal (GtkWidget *widget,
GdkDevice *device,
GtkImageDefinition *icon,
{
GtkDragSourceInfo *info;
GtkWidget *toplevel;
- GdkDragContext *context;
+ GdkDrag *drag;
int dx, dy;
GtkDragContent *content;
content->widget = g_object_ref (widget);
content->formats = gdk_content_formats_ref (target_list);
- context = gdk_drag_begin (gtk_widget_get_surface (toplevel), device, GDK_CONTENT_PROVIDER (content), actions, dx, dy);
- if (context == NULL)
+ drag = gdk_drag_begin (gtk_widget_get_surface (toplevel), device, GDK_CONTENT_PROVIDER (content), actions, dx, dy);
+ if (drag == NULL)
{
g_object_unref (content);
return NULL;
}
- content->context = context;
+ content->drag = drag;
g_object_unref (content);
- info = gtk_drag_get_source_info (context, TRUE);
+ info = gtk_drag_get_source_info (drag, TRUE);
g_object_set_data (G_OBJECT (widget), I_("gtk-info"), info);
gtk_widget_reset_controllers (widget);
- g_signal_emit_by_name (widget, "drag-begin", info->context);
+ g_signal_emit_by_name (widget, "drag-begin", info->drag);
/* Ensure that we have an icon before we start the drag; the
* application may have set one in ::drag_begin, or it may
{
if (icon)
{
- set_icon_helper (info->context, icon, 0, 0);
+ set_icon_helper (info->drag, icon, 0, 0);
}
else
{
icon = gtk_image_definition_new_icon_name ("text-x-generic");
- set_icon_helper (info->context, icon, 0, 0);
+ set_icon_helper (info->drag, icon, 0, 0);
gtk_image_definition_unref (icon);
}
}
- g_signal_connect (context, "drop-performed",
- G_CALLBACK (gtk_drag_context_drop_performed_cb), info);
- g_signal_connect (context, "dnd-finished",
- G_CALLBACK (gtk_drag_context_dnd_finished_cb), info);
- g_signal_connect (context, "cancel",
- G_CALLBACK (gtk_drag_context_cancel_cb), info);
+ g_signal_connect (drag, "drop-performed",
+ G_CALLBACK (gtk_drag_drop_performed_cb), info);
+ g_signal_connect (drag, "dnd-finished",
+ G_CALLBACK (gtk_drag_dnd_finished_cb), info);
+ g_signal_connect (drag, "cancel",
+ G_CALLBACK (gtk_drag_cancel_cb), info);
- return info->context;
+ return info->drag;
}
/**
*
* Returns: (transfer none): the context for this drag
*/
-GdkDragContext *
+GdkDrag *
gtk_drag_begin_with_coordinates (GtkWidget *widget,
GdkDevice *device,
GdkContentFormats *targets,
}
static void
-gtk_drag_set_icon_widget_internal (GdkDragContext *context,
+gtk_drag_set_icon_widget_internal (GdkDrag *drag,
GtkWidget *widget,
gint hot_x,
gint hot_y,
g_return_if_fail (!GTK_IS_WINDOW (widget));
- info = gtk_drag_get_source_info (context, FALSE);
+ info = gtk_drag_get_source_info (drag, FALSE);
if (info == NULL)
{
if (destroy_on_release)
g_signal_connect (widget, "destroy", G_CALLBACK (icon_widget_destroyed), info);
- gdk_drag_context_set_hotspot (context, hot_x, hot_y);
+ gdk_drag_set_hotspot (drag, hot_x, hot_y);
if (!info->icon_window)
{
GdkDisplay *display;
- display = gdk_drag_context_get_display (context);
+ display = gdk_drag_get_display (drag);
info->icon_window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_window_set_type_hint (GTK_WINDOW (info->icon_window), GDK_SURFACE_TYPE_HINT_DND);
gtk_style_context_remove_class (gtk_widget_get_style_context (info->icon_window), "background");
gtk_window_set_hardcoded_surface (GTK_WINDOW (info->icon_window),
- gdk_drag_context_get_drag_surface (context));
+ gdk_drag_get_drag_surface (drag));
gtk_widget_show (info->icon_window);
}
/**
* gtk_drag_set_icon_widget:
- * @context: the context for a drag. (This must be called
- with a context for the source side of a drag)
+ * @drag: the context for a drag
* @widget: a widget to use as an icon
* @hot_x: the X offset within @widget of the hotspot
* @hot_y: the Y offset within @widget of the hotspot
* signal and destroy it yourself.
*/
void
-gtk_drag_set_icon_widget (GdkDragContext *context,
+gtk_drag_set_icon_widget (GdkDrag *drag,
GtkWidget *widget,
gint hot_x,
gint hot_y)
{
- g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
+ g_return_if_fail (GDK_IS_DRAG (drag));
g_return_if_fail (GTK_IS_WIDGET (widget));
- gtk_drag_set_icon_widget_internal (context, widget, hot_x, hot_y, FALSE);
+ gtk_drag_set_icon_widget_internal (drag, widget, hot_x, hot_y, FALSE);
}
static void
-set_icon_helper (GdkDragContext *context,
+set_icon_helper (GdkDrag *drag,
GtkImageDefinition *def,
gint hot_x,
gint hot_y)
widget = gtk_image_new ();
gtk_style_context_add_class (gtk_widget_get_style_context (widget), "drag-icon");
gtk_image_set_from_definition (GTK_IMAGE (widget), def);
- gtk_drag_set_icon_widget_internal (context, widget, hot_x, hot_y, TRUE);
+ gtk_drag_set_icon_widget_internal (drag, widget, hot_x, hot_y, TRUE);
}
void
-gtk_drag_set_icon_definition (GdkDragContext *context,
+gtk_drag_set_icon_definition (GdkDrag *drag,
GtkImageDefinition *def,
gint hot_x,
gint hot_y)
{
- g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
+ g_return_if_fail (GDK_IS_DRAG (drag));
g_return_if_fail (def != NULL);
- set_icon_helper (context, def, hot_x, hot_y);
+ set_icon_helper (drag, def, hot_x, hot_y);
}
/**
* gtk_drag_set_icon_paintable:
- * @context: the context for a drag (This must be called
- * with a context for the source side of a drag)
+ * @drag: the context for a drag
* @paintable: the #GdkPaintable to use as icon
* @hot_x: the X offset of the hotspot within the icon
* @hot_y: the Y offset of the hotspot within the icon
* mouse cursor.
*/
void
-gtk_drag_set_icon_paintable (GdkDragContext *context,
+gtk_drag_set_icon_paintable (GdkDrag *drag,
GdkPaintable *paintable,
int hot_x,
int hot_y)
{
GtkWidget *widget;
- g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
+ g_return_if_fail (GDK_IS_DRAG (drag));
g_return_if_fail (GDK_IS_PAINTABLE (paintable));
widget = gtk_picture_new_for_paintable (paintable);
gtk_picture_set_can_shrink (GTK_PICTURE (widget), FALSE);
- gtk_drag_set_icon_widget_internal (context, widget, hot_x, hot_y, TRUE);
+ gtk_drag_set_icon_widget_internal (drag, widget, hot_x, hot_y, TRUE);
}
/**
* gtk_drag_set_icon_name:
- * @context: the context for a drag (This must be called
- * with a context for the source side of a drag)
+ * @drag: the context for a drag
* @icon_name: name of icon to use
* @hot_x: the X offset of the hotspot within the icon
* @hot_y: the Y offset of the hotspot within the icon
* @hot_x and @hot_y have to be used with care.
*/
void
-gtk_drag_set_icon_name (GdkDragContext *context,
+gtk_drag_set_icon_name (GdkDrag *drag,
const gchar *icon_name,
gint hot_x,
gint hot_y)
{
GtkImageDefinition *def;
- g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
+ g_return_if_fail (GDK_IS_DRAG (drag));
g_return_if_fail (icon_name != NULL && icon_name[0] != '\0');
def = gtk_image_definition_new_icon_name (icon_name);
- set_icon_helper (context, def, hot_x, hot_y);
+ set_icon_helper (drag, def, hot_x, hot_y);
gtk_image_definition_unref (def);
}
/**
* gtk_drag_set_icon_gicon:
- * @context: the context for a drag (This must be called
- * with a context for the source side of a drag)
+ * @drag: the context for a drag
* @icon: a #GIcon
* @hot_x: the X offset of the hotspot within the icon
* @hot_y: the Y offset of the hotspot within the icon
* for more details about using icons in drag and drop.
*/
void
-gtk_drag_set_icon_gicon (GdkDragContext *context,
+gtk_drag_set_icon_gicon (GdkDrag *drag,
GIcon *icon,
gint hot_x,
gint hot_y)
{
GtkImageDefinition *def;
- g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
+ g_return_if_fail (GDK_IS_DRAG (drag));
g_return_if_fail (icon != NULL);
def = gtk_image_definition_new_gicon (icon);
- set_icon_helper (context, def, hot_x, hot_y);
+ set_icon_helper (drag, def, hot_x, hot_y);
gtk_image_definition_unref (def);
}
/**
* gtk_drag_set_icon_default:
- * @context: the context for a drag (This must be called
- * with a context for the source side of a drag)
+ * @drag: the context for a drag
*
* Sets the icon for a particular drag to the default
* icon.
*/
void
-gtk_drag_set_icon_default (GdkDragContext *context)
+gtk_drag_set_icon_default (GdkDrag *drag)
{
- g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
+ g_return_if_fail (GDK_IS_DRAG (drag));
- gtk_drag_set_icon_name (context, "text-x-generic", -2, -2);
+ gtk_drag_set_icon_name (drag, "text-x-generic", -2, -2);
}
/* Clean up from the drag, and display snapback, if necessary. */
if (!success)
g_signal_emit_by_name (info->widget, "drag-failed",
- info->context, result, &success);
+ info->drag, result, &success);
- gdk_drag_drop_done (info->context, success);
+ gdk_drag_drop_done (info->drag, success);
gtk_drag_source_info_destroy (info);
}
static void
gtk_drag_source_info_destroy (GtkDragSourceInfo *info)
{
- g_signal_handlers_disconnect_by_func (info->context,
- gtk_drag_context_drop_performed_cb,
- info);
- g_signal_handlers_disconnect_by_func (info->context,
- gtk_drag_context_dnd_finished_cb,
- info);
- g_signal_handlers_disconnect_by_func (info->context,
- gtk_drag_context_cancel_cb,
- info);
-
- g_signal_emit_by_name (info->widget, "drag-end", info->context);
+ g_signal_handlers_disconnect_by_func (info->drag, gtk_drag_drop_performed_cb, info);
+ g_signal_handlers_disconnect_by_func (info->drag, gtk_drag_dnd_finished_cb, info);
+ g_signal_handlers_disconnect_by_func (info->drag, gtk_drag_cancel_cb, info);
+
+ g_signal_emit_by_name (info->widget, "drag-end", info->drag);
g_object_set_data (G_OBJECT (info->widget), I_("gtk-info"), NULL);
g_source_remove (info->drop_timeout);
/* keep the icon_window alive until the (possible) drag cancel animation is done */
- g_object_set_data_full (G_OBJECT (info->context), "former-gtk-source-info", info, (GDestroyNotify)gtk_drag_source_info_free);
+ g_object_set_data_full (G_OBJECT (info->drag), "former-gtk-source-info", info, (GDestroyNotify)gtk_drag_source_info_free);
- gtk_drag_clear_source_info (info->context);
- g_object_unref (info->context);
+ gtk_drag_clear_source_info (info->drag);
+ g_object_unref (info->drag);
}
/* Called on cancellation of a drag, either by the user
}
static void
-gtk_drag_context_drop_performed_cb (GdkDragContext *context,
- GtkDragSourceInfo *info)
+gtk_drag_drop_performed_cb (GdkDrag *drag,
+ GtkDragSourceInfo *info)
{
gtk_drag_drop (info);
}
static void
-gtk_drag_context_cancel_cb (GdkDragContext *context,
- GdkDragCancelReason reason,
- GtkDragSourceInfo *info)
+gtk_drag_cancel_cb (GdkDrag *drag,
+ GdkDragCancelReason reason,
+ GtkDragSourceInfo *info)
{
GtkDragResult result;
}
static void
-gtk_drag_context_dnd_finished_cb (GdkDragContext *context,
- GtkDragSourceInfo *info)
+gtk_drag_dnd_finished_cb (GdkDrag *drag,
+ GtkDragSourceInfo *info)
{
- if (gdk_drag_context_get_selected_action (context) == GDK_ACTION_MOVE)
+ if (gdk_drag_get_selected_action (drag) == GDK_ACTION_MOVE)
{
g_signal_emit_by_name (info->widget,
"drag-data-delete",
- context);
+ drag);
}
gtk_drag_source_info_destroy (info);
/**
* gtk_drag_cancel:
- * @context: a #GdkDragContext, as e.g. returned by gtk_drag_begin_with_coordinates()
+ * @drag: a drag context, as e.g. returned by gtk_drag_begin_with_coordinates()
*
* Cancels an ongoing drag operation on the source side.
*
* #GtkWidget::drag-failed is set to @GTK_DRAG_RESULT_ERROR.
*/
void
-gtk_drag_cancel (GdkDragContext *context)
+gtk_drag_cancel (GdkDrag *drag)
{
GtkDragSourceInfo *info;
- g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
+ g_return_if_fail (GDK_IS_DRAG (drag));
- info = gtk_drag_get_source_info (context, FALSE);
+ info = gtk_drag_get_source_info (drag, FALSE);
if (info != NULL)
gtk_drag_cancel_internal (info, GTK_DRAG_RESULT_ERROR);
}
GdkAtom target);
GDK_AVAILABLE_IN_ALL
-GtkWidget *gtk_drag_get_source_widget (GdkDragContext *context);
+GtkWidget *gtk_drag_get_source_widget (GdkDrag *drag);
GDK_AVAILABLE_IN_ALL
void gtk_drag_highlight (GtkWidget *widget);
/* Source side */
GDK_AVAILABLE_IN_ALL
-GdkDragContext *gtk_drag_begin_with_coordinates (GtkWidget *widget,
- GdkDevice *device,
- GdkContentFormats *targets,
- GdkDragAction actions,
- gint x,
- gint y);
+GdkDrag *gtk_drag_begin_with_coordinates (GtkWidget *widget,
+ GdkDevice *device,
+ GdkContentFormats *targets,
+ GdkDragAction actions,
+ gint x,
+ gint y);
GDK_AVAILABLE_IN_ALL
-void gtk_drag_cancel (GdkDragContext *context);
+void gtk_drag_cancel (GdkDrag *drag);
GDK_AVAILABLE_IN_ALL
-void gtk_drag_set_icon_widget (GdkDragContext *context,
+void gtk_drag_set_icon_widget (GdkDrag *drag,
GtkWidget *widget,
gint hot_x,
gint hot_y);
GDK_AVAILABLE_IN_ALL
-void gtk_drag_set_icon_paintable (GdkDragContext *context,
+void gtk_drag_set_icon_paintable (GdkDrag *drag,
GdkPaintable *paintable,
int hot_x,
int hot_y);
GDK_AVAILABLE_IN_ALL
-void gtk_drag_set_icon_name (GdkDragContext *context,
+void gtk_drag_set_icon_name (GdkDrag *drag,
const gchar *icon_name,
gint hot_x,
gint hot_y);
GDK_AVAILABLE_IN_ALL
-void gtk_drag_set_icon_gicon (GdkDragContext *context,
+void gtk_drag_set_icon_gicon (GdkDrag *drag,
GIcon *icon,
gint hot_x,
gint hot_y);
GDK_AVAILABLE_IN_ALL
-void gtk_drag_set_icon_default (GdkDragContext *context);
+void gtk_drag_set_icon_default (GdkDrag *drag);
GDK_AVAILABLE_IN_ALL
gboolean gtk_drag_check_threshold (GtkWidget *widget,
G_BEGIN_DECLS
-GdkDragContext * gtk_drag_begin_internal (GtkWidget *widget,
+GdkDrag * gtk_drag_begin_internal (GtkWidget *widget,
GdkDevice *device,
GtkImageDefinition *icon,
GdkContentFormats *target_list,
GdkDragAction actions,
int x,
int y);
-void gtk_drag_set_icon_definition (GdkDragContext *context,
+void gtk_drag_set_icon_definition (GdkDrag *drag,
GtkImageDefinition *def,
gint hot_x,
gint hot_y);
* |[<!-- language="C" -->
* static void
* drag_motion (GtkWidget *widget,
- * GdkDragContext *context,
+ * GdkDrag *drag,
* gint x,
* gint y,
* guint time)
GdkDrop *drop,
GtkSelectionData *selection_data);
static void gtk_entry_drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data);
static void gtk_entry_drag_data_delete (GtkWidget *widget,
- GdkDragContext *context);
+ GdkDrag *drag);
static void gtk_entry_drag_begin (GtkWidget *widget,
- GdkDragContext *context);
+ GdkDrag *drag);
static void gtk_entry_drag_end (GtkWidget *widget,
- GdkDragContext *context);
+ GdkDrag *drag);
/* GtkEditable method implementations
static void
gtk_entry_drag_begin (GtkWidget *widget,
- GdkDragContext *context)
+ GdkDrag *drag)
{
GtkEntry *entry = GTK_ENTRY (widget);
GtkEntryPrivate *priv = gtk_entry_get_instance_private (entry);
{
if (icon_info->in_drag)
{
- gtk_drag_set_icon_definition (context,
+ gtk_drag_set_icon_definition (drag,
gtk_image_get_definition (GTK_IMAGE (icon_info->widget)),
-2, -2);
return;
paintable = gtk_text_util_create_drag_icon (widget, text, -1);
gtk_entry_get_pixel_ranges (entry, &ranges, &n_ranges);
- gtk_drag_set_icon_paintable (context,
+ gtk_drag_set_icon_paintable (drag,
paintable,
priv->drag_start_x - ranges[0],
priv->drag_start_y);
static void
gtk_entry_drag_end (GtkWidget *widget,
- GdkDragContext *context)
+ GdkDrag *drag)
{
GtkEntry *entry = GTK_ENTRY (widget);
GtkEntryPrivate *priv = gtk_entry_get_instance_private (entry);
GdkDrop *drop)
{
GtkWidget *widget = GTK_WIDGET (entry);
- GdkDragContext *drag = gdk_drop_get_drag (drop);
+ GdkDrag *drag = gdk_drop_get_drag (drop);
GtkWidget *source_widget = gtk_drag_get_source_widget (drag);
GdkDragAction actions;
static void
gtk_entry_drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data)
{
GtkEntry *entry = GTK_ENTRY (widget);
static void
gtk_entry_drag_data_delete (GtkWidget *widget,
- GdkDragContext *context)
+ GdkDrag *drag)
{
GtkEntry *entry = GTK_ENTRY (widget);
GtkEntryPrivate *priv = gtk_entry_get_instance_private (entry);
/* Source side drag signals */
static void gtk_icon_view_drag_begin (GtkWidget *widget,
- GdkDragContext *context);
+ GdkDrag *drag);
static void gtk_icon_view_drag_end (GtkWidget *widget,
- GdkDragContext *context);
+ GdkDrag *drag);
static void gtk_icon_view_drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data);
static void gtk_icon_view_drag_data_delete (GtkWidget *widget,
- GdkDragContext *context);
+ GdkDrag *drag);
/* Target side drag signals */
static void gtk_icon_view_drag_leave (GtkWidget *widget,
}
static void
-set_source_row (GdkDragContext *context,
+set_source_row (GdkDrag *drag,
GtkTreeModel *model,
GtkTreePath *source_row)
{
if (source_row)
- g_object_set_data_full (G_OBJECT (context),
+ g_object_set_data_full (G_OBJECT (drag),
I_("gtk-icon-view-source-row"),
gtk_tree_row_reference_new (model, source_row),
(GDestroyNotify) gtk_tree_row_reference_free);
else
- g_object_set_data_full (G_OBJECT (context),
+ g_object_set_data_full (G_OBJECT (drag),
I_("gtk-icon-view-source-row"),
NULL, NULL);
}
static GtkTreePath*
-get_source_row (GdkDragContext *context)
+get_source_row (GdkDrag *drag)
{
GtkTreeRowReference *ref;
- ref = g_object_get_data (G_OBJECT (context), "gtk-icon-view-source-row");
+ ref = g_object_get_data (G_OBJECT (drag), "gtk-icon-view-source-row");
if (ref)
return gtk_tree_row_reference_get_path (ref);
GdkDevice *device)
{
GtkWidget *widget = GTK_WIDGET (icon_view);
- GdkDragContext *context;
+ GdkDrag *drag;
GtkTreePath *path = NULL;
GtkTreeModel *model;
gboolean retval = FALSE;
retval = TRUE;
- context = gtk_drag_begin_with_coordinates (widget,
- device,
- gtk_drag_source_get_target_list (widget),
- icon_view->priv->source_actions,
- icon_view->priv->press_start_x,
- icon_view->priv->press_start_y);
+ drag = gtk_drag_begin_with_coordinates (widget,
+ device,
+ gtk_drag_source_get_target_list (widget),
+ icon_view->priv->source_actions,
+ icon_view->priv->press_start_x,
+ icon_view->priv->press_start_y);
- set_source_row (context, model, path);
+ set_source_row (drag, model, path);
out:
if (path)
/* Source side drag signals */
static void
gtk_icon_view_drag_begin (GtkWidget *widget,
- GdkDragContext *context)
+ GdkDrag *drag)
{
GtkIconView *icon_view;
GtkIconViewItem *item;
icon = gtk_icon_view_create_drag_icon (icon_view, path);
gtk_tree_path_free (path);
- gtk_drag_set_icon_paintable (context, icon, x, y);
+ gtk_drag_set_icon_paintable (drag, icon, x, y);
g_object_unref (icon);
}
static void
gtk_icon_view_drag_end (GtkWidget *widget,
- GdkDragContext *context)
+ GdkDrag *drag)
{
/* do nothing */
}
static void
gtk_icon_view_drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data)
{
GtkIconView *icon_view;
if (!icon_view->priv->source_set)
return;
- source_row = get_source_row (context);
+ source_row = get_source_row (drag);
if (source_row == NULL)
return;
static void
gtk_icon_view_drag_data_delete (GtkWidget *widget,
- GdkDragContext *context)
+ GdkDrag *drag)
{
GtkTreeModel *model;
GtkIconView *icon_view;
if (!icon_view->priv->source_set)
return;
- source_row = get_source_row (context);
+ source_row = get_source_row (drag);
if (source_row == NULL)
return;
gtk_tree_path_free (source_row);
- set_source_row (context, NULL, NULL);
+ set_source_row (drag, NULL, NULL);
}
/* Target side drag signals */
gtk_icon_view_get_action (GtkWidget *treeview,
GdkDrop *drop)
{
- GdkDragContext *drag = gdk_drop_get_drag (drop);
+ GdkDrag *drag = gdk_drop_get_drag (drop);
GtkWidget *source_widget = gtk_drag_get_source_widget (drag);
GdkDragAction actions;
static void gtk_label_setup_mnemonic (GtkLabel *label,
guint last_key);
static void gtk_label_drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data);
static void gtk_label_buildable_interface_init (GtkBuildableIface *iface);
static void
drag_begin_cb (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
gpointer data)
{
GtkLabel *label = GTK_LABEL (widget);
if (paintable)
{
- gtk_drag_set_icon_paintable (context, paintable, 0, 0);
+ gtk_drag_set_icon_paintable (drag, paintable, 0, 0);
g_object_unref (paintable);
}
else
{
- gtk_drag_set_icon_default (context);
+ gtk_drag_set_icon_default (drag);
}
}
static void
gtk_label_drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data)
{
gtk_label_set_selection_text (GTK_LABEL (widget), selection_data);
static void gtk_link_button_clicked (GtkButton *button);
static gboolean gtk_link_button_popup_menu (GtkWidget *widget);
static void gtk_link_button_drag_data_get_cb (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection,
gpointer user_data);
static gboolean gtk_link_button_query_tooltip_cb (GtkWidget *widget,
static void
gtk_link_button_drag_data_get_cb (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection,
gpointer user_data)
{
/*** Drag and drop Methods ***/
static void gtk_notebook_drag_begin (GtkWidget *widget,
- GdkDragContext *context);
+ GdkDrag *drag);
static void gtk_notebook_drag_end (GtkWidget *widget,
- GdkDragContext *context);
+ GdkDrag *drag);
static gboolean gtk_notebook_drag_failed (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkDragResult result);
static gboolean gtk_notebook_drag_motion (GtkWidget *widget,
GdkDrop *drop,
gint x,
gint y);
static void gtk_notebook_drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *data);
static void gtk_notebook_drag_data_received (GtkWidget *widget,
GdkDrop *drop,
static void
gtk_notebook_drag_begin (GtkWidget *widget,
- GdkDragContext *context)
+ GdkDrag *drag)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
GtkNotebookPrivate *priv = notebook->priv;
gtk_style_context_add_class (gtk_widget_get_style_context (priv->dnd_child), "background");
- gtk_drag_set_icon_widget (context, tab_label, -2, -2);
- g_object_set_data (G_OBJECT (priv->dnd_child), "drag-context", context);
+ gtk_drag_set_icon_widget (drag, tab_label, -2, -2);
+ g_object_set_data (G_OBJECT (priv->dnd_child), "drag-context", drag);
g_object_unref (tab_label);
}
static void
gtk_notebook_drag_end (GtkWidget *widget,
- GdkDragContext *context)
+ GdkDrag *drag)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
GtkNotebookPrivate *priv = notebook->priv;
GtkNotebook *dest_notebook = NULL;
gint x, y;
- gdk_device_get_position (gdk_drag_context_get_device (context), &x, &y);
+ gdk_device_get_position (gdk_drag_get_device (drag), &x, &y);
g_signal_emit (notebook, notebook_signals[CREATE_WINDOW], 0,
priv->detached_tab->child, x, y, &dest_notebook);
static gboolean
gtk_notebook_drag_failed (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkDragResult result)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
GtkNotebook *dest_notebook = NULL;
gint x, y;
- gdk_device_get_position (gdk_drag_context_get_device (context), &x, &y);
+ gdk_device_get_position (gdk_drag_get_device (drag), &x, &y);
g_signal_emit (notebook, notebook_signals[CREATE_WINDOW], 0,
priv->detached_tab->child, x, y, &dest_notebook);
static void
gtk_notebook_drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *data)
{
GtkNotebook *notebook = GTK_NOTEBOOK (widget);
GtkSelectionData *data)
{
GtkNotebook *notebook;
- GdkDragContext *drag;
+ GdkDrag *drag;
GtkWidget *source_widget;
GtkWidget **child;
if (priv->operation == DRAG_OPERATION_DETACH && !priv->remove_in_detach)
{
- GdkDragContext *context;
+ GdkDrag *drag;
- context = (GdkDragContext *)g_object_get_data (G_OBJECT (priv->dnd_child), "drag-context");
- gtk_drag_cancel (context);
+ drag = (GdkDrag *)g_object_get_data (G_OBJECT (priv->dnd_child), "drag-context");
+ gtk_drag_cancel (drag);
}
}
if (priv->switch_tab == list)
* |[<!-- language="C" -->
* static void
* on_drag_data_received (GtkWidget *widget,
- * GdkDragContext *context,
+ * GdkDrag *drag,
* GtkSelectionData *data,
* guint time,
* gpointer user_data)
* GtkWidget *notebook;
* GtkWidget **child;
*
- * notebook = gtk_drag_get_source_widget (context);
+ * notebook = gtk_drag_get_source_widget (drag);
* child = (void*) gtk_selection_data_get_data (data);
*
* // process_widget (*child);
static void
button_drag_data_get_cb (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data,
gpointer data)
{
const gchar *primary,
const gchar *secondary);
GdkDragAction (* drag_action_requested) (GtkPlacesSidebar *sidebar,
- GdkDragContext *context,
+ GdkDrag *drag,
GFile *dest_file,
GList *source_file_list);
GdkDragAction (* drag_action_ask) (GtkPlacesSidebar *sidebar,
static void
drag_begin_callback (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
gpointer user_data)
{
GtkPlacesSidebar *sidebar = GTK_PLACES_SIDEBAR (user_data);
gtk_widget_set_opacity (drag_widget, 0.8);
- gtk_drag_set_icon_widget (context,
+ gtk_drag_set_icon_widget (drag,
drag_widget,
sidebar->drag_row_x,
sidebar->drag_row_y);
static void
drag_data_get_callback (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *data,
gpointer user_data)
{
static void
drag_end_callback (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
gpointer user_data)
{
stop_drop_feedback (GTK_PLACES_SIDEBAR (user_data));
/* Source side drag signals */
static void gtk_text_view_drag_begin (GtkWidget *widget,
- GdkDragContext *context);
+ GdkDrag *drag);
static void gtk_text_view_drag_end (GtkWidget *widget,
- GdkDragContext *context);
+ GdkDrag *drag);
static void gtk_text_view_drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data);
static void gtk_text_view_drag_data_delete (GtkWidget *widget,
- GdkDragContext *context);
+ GdkDrag *drag);
/* Target side drag signals */
static void gtk_text_view_drag_leave (GtkWidget *widget,
static void
drag_begin_cb (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
gpointer data)
{
GtkTextView *text_view = GTK_TEXT_VIEW (widget);
if (paintable)
{
- gtk_drag_set_icon_paintable (context, paintable, 0, 0);
+ gtk_drag_set_icon_paintable (drag, paintable, 0, 0);
g_object_unref (paintable);
}
else
{
- gtk_drag_set_icon_default (context);
+ gtk_drag_set_icon_default (drag);
}
}
static void
gtk_text_view_drag_begin (GtkWidget *widget,
- GdkDragContext *context)
+ GdkDrag *drag)
{
/* do nothing */
}
static void
gtk_text_view_drag_end (GtkWidget *widget,
- GdkDragContext *context)
+ GdkDrag *drag)
{
GtkTextView *text_view;
static void
gtk_text_view_drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data)
{
GtkTextView *text_view = GTK_TEXT_VIEW (widget);
static void
gtk_text_view_drag_data_delete (GtkWidget *widget,
- GdkDragContext *context)
+ GdkDrag *drag)
{
gtk_text_buffer_delete_selection (GTK_TEXT_VIEW (widget)->priv->buffer,
TRUE, GTK_TEXT_VIEW (widget)->priv->editable);
gtk_text_view_get_action (GtkWidget *textview,
GdkDrop *drop)
{
- GdkDragContext *drag = gdk_drop_get_drag (drop);
+ GdkDrag *drag = gdk_drop_get_drag (drop);
GtkWidget *source_widget = gtk_drag_get_source_widget (drag);
GdkDragAction actions;
/* Source side drag signals */
static void gtk_tree_view_drag_begin (GtkWidget *widget,
- GdkDragContext *context);
+ GdkDrag *drag);
static void gtk_tree_view_drag_end (GtkWidget *widget,
- GdkDragContext *context);
+ GdkDrag *drag);
static void gtk_tree_view_drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data);
static void gtk_tree_view_drag_data_delete (GtkWidget *widget,
- GdkDragContext *context);
+ GdkDrag *drag);
/* Target side drag signals */
static void gtk_tree_view_drag_leave (GtkWidget *widget,
/* Drag-and-drop */
static void
-set_source_row (GdkDragContext *context,
+set_source_row (GdkDrag *drag,
GtkTreeModel *model,
GtkTreePath *source_row)
{
- g_object_set_data_full (G_OBJECT (context),
+ g_object_set_data_full (G_OBJECT (drag),
I_("gtk-tree-view-source-row"),
source_row ? gtk_tree_row_reference_new (model, source_row) : NULL,
(GDestroyNotify) (source_row ? gtk_tree_row_reference_free : NULL));
}
static GtkTreePath*
-get_source_row (GdkDragContext *context)
+get_source_row (GdkDrag *drag)
{
GtkTreeRowReference *ref =
- g_object_get_data (G_OBJECT (context), "gtk-tree-view-source-row");
+ g_object_get_data (G_OBJECT (drag), "gtk-tree-view-source-row");
if (ref)
return gtk_tree_row_reference_get_path (ref);
{
GtkWidget *widget = GTK_WIDGET (tree_view);
gdouble start_x, start_y, offset_x, offset_y;
- GdkDragContext *context;
+ GdkDrag *drag;
TreeViewDragInfo *di;
GtkTreePath *path = NULL;
gint button;
gtk_gesture_set_state (GTK_GESTURE (tree_view->priv->drag_gesture),
GTK_EVENT_SEQUENCE_CLAIMED);
- context = gtk_drag_begin_with_coordinates (widget,
- gtk_gesture_get_device (GTK_GESTURE (tree_view->priv->drag_gesture)),
- gtk_drag_source_get_target_list (widget),
- di->source_actions,
- start_x, start_y);
+ drag = gtk_drag_begin_with_coordinates (widget,
+ gtk_gesture_get_device (GTK_GESTURE (tree_view->priv->drag_gesture)),
+ gtk_drag_source_get_target_list (widget),
+ di->source_actions,
+ start_x, start_y);
- set_source_row (context, model, path);
+ set_source_row (drag, model, path);
out:
if (path)
static void
gtk_tree_view_drag_begin (GtkWidget *widget,
- GdkDragContext *context)
+ GdkDrag *drag)
{
GtkTreeView *tree_view;
GtkTreePath *path = NULL;
if (!path)
return;
- row_pix = gtk_tree_view_create_row_drag_icon (tree_view,
- path);
+ row_pix = gtk_tree_view_create_row_drag_icon (tree_view, path);
- gtk_drag_set_icon_paintable (context, row_pix, tree_view->priv->press_start_x + 1, 1);
+ gtk_drag_set_icon_paintable (drag, row_pix, tree_view->priv->press_start_x + 1, 1);
g_object_unref (row_pix);
gtk_tree_path_free (path);
static void
gtk_tree_view_drag_end (GtkWidget *widget,
- GdkDragContext *context)
+ GdkDrag *drag)
{
GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
/* Default signal implementations for the drag signals */
static void
gtk_tree_view_drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data)
{
GtkTreeView *tree_view;
if (di == NULL)
return;
- source_row = get_source_row (context);
+ source_row = get_source_row (drag);
if (source_row == NULL)
return;
static void
gtk_tree_view_drag_data_delete (GtkWidget *widget,
- GdkDragContext *context)
+ GdkDrag *drag)
{
TreeViewDragInfo *di;
GtkTreeModel *model;
if (di == NULL)
return;
- source_row = get_source_row (context);
+ source_row = get_source_row (drag);
if (source_row == NULL)
return;
- gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (model),
- source_row);
+ gtk_tree_drag_source_drag_data_delete (GTK_TREE_DRAG_SOURCE (model), source_row);
gtk_tree_path_free (source_row);
- set_source_row (context, NULL, NULL);
+ set_source_row (drag, NULL, NULL);
}
static void
gtk_tree_view_get_action (GtkWidget *treeview,
GdkDrop *drop)
{
- GdkDragContext *drag = gdk_drop_get_drag (drop);
+ GdkDrag *drag = gdk_drop_get_drag (drop);
GtkWidget *source_widget = gtk_drag_get_source_widget (drag);
GdkDragAction actions;
/**
* GtkWidget::drag-begin:
* @widget: the object which received the signal
- * @context: the drag context
+ * @context: the drag context
*
* The ::drag-begin signal is emitted on the drag source when a drag is
* started. A typical reason to connect to this signal is to set up a
NULL, NULL,
NULL,
G_TYPE_NONE, 1,
- GDK_TYPE_DRAG_CONTEXT);
+ GDK_TYPE_DRAG);
/**
* GtkWidget::drag-end:
NULL, NULL,
NULL,
G_TYPE_NONE, 1,
- GDK_TYPE_DRAG_CONTEXT);
+ GDK_TYPE_DRAG);
/**
* GtkWidget::drag-data-delete:
NULL, NULL,
NULL,
G_TYPE_NONE, 1,
- GDK_TYPE_DRAG_CONTEXT);
+ GDK_TYPE_DRAG);
/**
* GtkWidget::drag-failed:
_gtk_boolean_handled_accumulator, NULL,
_gtk_marshal_BOOLEAN__OBJECT_ENUM,
G_TYPE_BOOLEAN, 2,
- GDK_TYPE_DRAG_CONTEXT,
+ GDK_TYPE_DRAG,
GTK_TYPE_DRAG_RESULT);
/**
NULL, NULL,
_gtk_marshal_VOID__OBJECT_BOXED,
G_TYPE_NONE, 2,
- GDK_TYPE_DRAG_CONTEXT,
+ GDK_TYPE_DRAG,
GTK_TYPE_SELECTION_DATA | G_SIGNAL_TYPE_STATIC_SCOPE);
/**
GdkEvent *event);
/* Source side drag signals */
- void (* drag_begin) (GtkWidget *widget,
- GdkDragContext *context);
+ void (* drag_begin) (GtkWidget *widget,
+ GdkDrag *drag);
void (* drag_end) (GtkWidget *widget,
- GdkDragContext *context);
+ GdkDrag *drag);
void (* drag_data_get) (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data);
void (* drag_data_delete) (GtkWidget *widget,
- GdkDragContext *context);
+ GdkDrag *drag);
/* Target side drag signals */
void (* drag_leave) (GtkWidget *widget,
GdkDrop *drop,
GtkSelectionData *selection_data);
gboolean (* drag_failed) (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkDragResult result);
/* Signals used only for keybindings */
gint y)
{
GtkWidget *source_widget;
- GdkDragContext *drag;
+ GdkDrag *drag;
char *s;
if (!have_drag)
void
source_drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data,
gpointer data)
{
void
source_drag_data_delete (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
gpointer data)
{
g_print ("Delete the data!\n");
static void
image_drag_begin (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
gpointer data)
{
GdkPaintable *paintable;
hot_y = size;
break;
}
- gtk_drag_set_icon_paintable (context, paintable, hot_x, hot_y);
+ gtk_drag_set_icon_paintable (drag, paintable, hot_x, hot_y);
g_object_unref (paintable);
}
}
static void
-window_drag_end (GtkWidget *widget, GdkDragContext *context, gpointer data)
+window_drag_end (GtkWidget *widget,
+ GdkDrag *drag,
+ gpointer data)
{
GtkWidget *window = data;
static void
window_drag_begin (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
gpointer data)
{
GdkPaintable *paintable;
else
g_print ("reusing drag widget\n");
- gtk_drag_set_icon_widget (context, image, 0, 0);
+ gtk_drag_set_icon_widget (drag, image, 0, 0);
if (hotspot == CENTER)
g_signal_connect (widget, "drag-end", G_CALLBACK (window_drag_end), image);
void
image_drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data,
gpointer data)
{
static void
spinner_drag_begin (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
gpointer data)
{
GtkWidget *spinner;
"visible", TRUE,
"active", TRUE,
NULL);
- gtk_drag_set_icon_widget (context, spinner, 0, 0);
- g_object_set_data (G_OBJECT (context), "spinner", spinner);
+ gtk_drag_set_icon_widget (drag, spinner, 0, 0);
+ g_object_set_data (G_OBJECT (drag), "spinner", spinner);
}
static void
spinner_drag_end (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
gpointer data)
{
GtkWidget *spinner;
g_print ("GtkWidget::drag-end\n");
- spinner = g_object_get_data (G_OBJECT (context), "spinner");
+ spinner = g_object_get_data (G_OBJECT (drag), "spinner");
gtk_widget_destroy (spinner);
}
static gboolean
spinner_drag_failed (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkDragResult result,
gpointer data)
{
void
spinner_drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data,
gpointer data)
{
static void
drag_begin_cb (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
gpointer user_data)
{
gint pos;
pos = gtk_entry_get_current_icon_drag_source (GTK_ENTRY (widget));
if (pos != -1)
- gtk_drag_set_icon_name (context, "dialog-information", 2, 2);
+ gtk_drag_set_icon_name (drag, "dialog-information", 2, 2);
}
static void
drag_data_get_cb (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *data,
gpointer user_data)
{
static void
drag_begin (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
gpointer data)
{
GtkWidget *image = GTK_WIDGET (data);
GdkPaintable *paintable;
paintable = gtk_image_get_paintable (GTK_IMAGE (image));
- gtk_drag_set_icon_paintable (context, paintable, -2, -2);
+ gtk_drag_set_icon_paintable (drag, paintable, -2, -2);
}
void
drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data,
gpointer data)
{
static void
drag_data_received (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data,
guint info,
guint32 time,
static void
drag_begin (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
gpointer data)
{
GtkWidget *row;
paintable = gtk_widget_paintable_new (row);
gtk_widget_translate_coordinates (widget, row, 0, 0, &x, &y);
- gtk_drag_set_icon_paintable (context, paintable, -x, -y);
+ gtk_drag_set_icon_paintable (drag, paintable, -x, -y);
g_object_unref (paintable);
}
void
drag_data_get (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
GtkSelectionData *selection_data,
gpointer data)
{
static void
on_notebook_drag_begin (GtkWidget *widget,
- GdkDragContext *context,
+ GdkDrag *drag,
gpointer data)
{
guint page_num;
page_num = gtk_notebook_get_current_page (GTK_NOTEBOOK (widget));
if (page_num > 2)
- gtk_drag_set_icon_name (context,
+ gtk_drag_set_icon_name (drag,
(page_num % 2) ? "help-browser" : "process-stop",
0, 0);
}
projects / gtk4.git / commitdiff